Merge partner-work: 合并双方开发结果（我方验证码/登出/布局 + 对方业务模块）

xyc

5 天以前 ec9b25a0799f3b39b4dea2d2ca8ea8491dddbaf4

Merge partner-work: 合并双方开发结果（我方验证码/登出/布局 + 对方业务模块）

 .gitignore

@@ -37,3 +37,28 @@
.DS_Store
Thumbs.db
desktop.ini

# ==== ??/?????????====
_shots/
*.nb3
*.dmp
backend.log*
energy-test.log
diag*.log
_*.py
_*.txt
_*.xlsx
_*.png
_*.json
_test_check*/
_test_passenger/
check_*.py
cmp*.py
dump_*.py
fix_*.py
inspect_*.py
patch_*.py
verify_*.py
write_readme.py
clear-bom.ps1
verify_city*.txt

 HANDOFF.md

@@ -3,9 +3,15 @@
> **用法**：新对话开始后，先读本文件 + é¡¹ç›®æ ¹ç›®å½• `AGENTS.md`，即可无缝接力。
> **每天结束时**：把当天进展、踩过的坑、新需求、未完成事项更新到本文件，然后可以放心开新对话。

## ä¸€ã€å½“前状态（2026-08-27）
- å‰åŽç«¯**运行中**（8090/8080 å·²ç›‘听，start-dev.ps1 å¯åŠ¨ï¼‰ï¼Œç™»å½•é¡µå·²æŽ¥å…¥çœŸå®žè®¤è¯ + è¡Œä¸ºéªŒè¯ç ã€‚
- 08-27 è¡Œä¸ºéªŒè¯ç æ”¹åŠ¨**未提交**（工作区有改动，见第十节）；此前的代码已入库 Gitee ç§æœ‰ä»“库（见第九节）。
## ä¸€ã€å½“前状态（2026-08-27 åˆå¹¶åŽï¼‰
- å‰åŽç«¯**运行中**（8090/8080 å·²ç›‘听，start-dev.ps1 å¯åŠ¨ï¼‰ï¼Œç™»å½•é¡µå·²æŽ¥å…¥çœŸå®žè®¤è¯ï¼ˆæ•°æ®åº“校验）+ è¡Œä¸ºéªŒè¯ç ã€‚
- **2026-08-27 å®ŒæˆåŒæ–¹å¼€å‘结果合并**：以对方（郑玉洁，另一开发人员）的代码为基础，并入我方三样改动
  ï¼ˆæ€åŠ¿å›¾/AI助手构想记录、登录行为验证码、登出与上下布局）。验证码采用**我方实现**（Captcha3D + åŽç«¯ captcha åŒ…，
  å†…存存储，无 Redis ä¾èµ–），对方独立实现的 ShapeCaptcha（Canvas+Redis）已弃用、不入库。
- æ–° git ä»“库迁移进行中：旧 Gitee ä»“库弃用，合并结果将提交到新仓库（地址见第九节，待用户提供后补全）。
- æ•°æ®åº“已补齐对方新增表（MySQL 8，库 traffic_audit，本机 3305）：h2031_enterprise_monthly、passenger_*、
  h204_*、investment_*、city_bus_monthly、city_taxi_monthly、city_taxi_auth、passenger_individual_monthly、audit_run；
  sys_user å·²åŠ  modules åˆ—ï¼›admin å¯†ç å·²é‡ç½®ä¸º BCrypt（admin/admin123）。
- æ— å·²çŸ¥é˜»å¡žæ€§é—®é¢˜ã€‚

## äºŒã€å¿«é€Ÿå¯åŠ¨
@@ -24,7 +30,10 @@
- åŽç«¯ï¼šSpring Boot 2.x + MyBatis Plus + EasyExcel，`traffic-audit-server`，端口 8090。
- æ•°æ®åº“：MySQL（本机 3305 ç«¯å£ï¼Œåº“名 `traffic_audit`；账号密码见 `traffic-audit-server/src/main/resources/application.yml`）。
- LLM：DeepSeek API（`deepseek-chat`，配置同样在 application.yml；注意不要把 API Key å†™è¿›ä»»ä½•æ–‡æ¡£ï¼‰ã€‚
- æ ¸å¿ƒæ¨¡å—：数据导入（5类）、审核引擎（规则驱动）、AI åˆ†æžï¼ˆè„±æ•+查库+解释生成）、报表生成（3类）、用户权限（三员分离）。
- æ ¸å¿ƒæ¨¡å—：数据导入（货运/旅客/城市客运/投资/能耗多类）、审核引擎（规则驱动）、AI åˆ†æžï¼ˆè„±æ•+查库+解释生成）、
  æŠ¥è¡¨ç”Ÿæˆï¼ˆè´§è¿/旅客/城市客运/投资/能耗 Tab å·¥ä½œå°ï¼‰ã€ç”¨æˆ·æƒé™ï¼ˆä¸‰å‘˜åˆ†ç¦»ï¼‰ã€æ“ä½œæ—¥å¿—。
- å¯¹æ–¹ï¼ˆéƒ‘玉洁）08-26/08-27 çš„完整开发记录见 `docs/同事开发记录-20260827.md`（含报表 Tab å·¥ä½œå°ã€ç›®å½•å¯¼å…¥ã€
  è§£é‡ŠæŒ‰éœ€å±•å¼€ã€åŠ¨æ€æŠ¥è¡¨æ ‡é¢˜ã€åŸŽå¸‚客运/公路旅客/投资/能耗模块等细节与踩坑）。

## å››ã€å·²å®ŒæˆåŠŸèƒ½ï¼ˆæˆªè‡³ 08-07）
- æ•°æ®å¯¼å…¥ï¼šH203-2月报、运政车辆、轨迹里程、规上规下拆分、货运量周转量；导入失败显示行号。
@@ -63,12 +72,15 @@
1. æ–°å¯¹è¯ç¬¬ä¸€æ­¥ï¼šè¯» `AGENTS.md` + `HANDOFF.md`；涉及 AI åˆ†æž/审核时参考 `docs/` ä¸Žæ•°æ®åº“表结构。
2. æ¯å¤©ç»“束时：更新 `HANDOFF.md`（进展、坑、新需求、待办），再关对话。
3. è·¨é¡¹ç›®å¯å¤ç”¨ç»éªŒæ²‰æ·€åˆ°æœºå™¨çº§é¡¶å±‚ AGENTS.md（本项目不再重复）。
## ä¹ã€Git ä»“库（2026-08-14 å»ºç«‹ï¼‰
- è¿œç¨‹ï¼šGitee **私有**仓库 https://gitee.com/jichengxiong/trafficAudit ï¼Œåˆ†æ”¯ `main`（提交身份 xyc <jc_xiong@hotmail.com>）。
## ä¹ã€Git ä»“库（2026-08-27 èµ·è¿ç§»åˆ°æ–°ä»“库）
- **旧仓库（弃用）**：Gitee https://gitee.com/jichengxiong/trafficAudit（2026-08-14 å»ºç«‹ï¼‰â€”—不再使用。
- **新仓库**：地址待补（用户提供账号/仓库名后填写）。合并后的 main åˆ†æ”¯å·²åŒ…含：原历史 + æˆ‘æ–¹ 08-27 æäº¤ + å¯¹æ–¹å¼€å‘结果分支 + åˆå¹¶æäº¤ã€‚
- å¯¹æ–¹æœªä½¿ç”¨ git：其开发结果以独立分支（partner-work）合入，合并提交 `Merge partner-work`。
- æ•æ„Ÿé…ç½®ä¸å…¥åº“：`traffic-audit-server/src/main/resources/application.yml` å·²åœ¨ `.gitignore` ä¸­ï¼Œ
  ä»“库内只提交占位符模板 `application.yml.example`（`${DEEPSEEK_API_KEY}` ç­‰ï¼‰ã€‚新环境：复制模板为 application.yml å¹¶å¡«çœŸå®žå€¼ã€‚
- æ—¥å¸¸æµç¨‹ï¼š`git add -A` â†’ `git commit -m "..."` â†’ `git push`（凭据已存 Windows å‡­æ®ç®¡ç†å™¨ï¼Œæœ¬æœº push æ— éœ€å†è¾“令牌；换机器需重新提供令牌）。
- æ³¨æ„ï¼š`backend.log`、`frontend.log`、`node_modules/`、`dist/`、`target/` ç­‰ä¸å…¥åº“。
- æ—¥å¸¸æµç¨‹ï¼š`git add -A` â†’ `git commit -m "..."` â†’ `git push`（凭据按新仓库要求配置）。
- æ³¨æ„ï¼š`backend.log`、`frontend.log`、`node_modules/`、`dist/`、`target/` ç­‰ä¸å…¥åº“ï¼›`docs/sql_city_bus.sql`、
  `docs/sql_city_taxi.sql` å·²å…¥åº“（建表+审核规则，MySQL 8 å¯ç”¨ï¼‰ã€‚

## åã€ä¼šè¯è®°å½•
- 2026-08-14：启动前后端验证正常（后均已停止）；建立 git ä»“库（新增 `.gitignore`、脱敏模板 `application.yml.example`，真实 `application.yml` ä¸å…¥åº“），创建 Gitee ç§æœ‰ä»“库 `jichengxiong/trafficAudit` å¹¶æŽ¨é€ `main`（2 commits：初始提交 + HANDOFF è¡¥å…… git è¯´æ˜Žï¼‰ã€‚
@@ -77,3 +89,16 @@
- 2026-08-27：登录功能改造完成——行为验证码（按提示顺序点击立体图形）。后端 security/captcha/CaptchaService.java ç›´æŽ¥ç”Ÿæˆç­‰è½´æµ‹å‡ ä½•é¢ï¼ˆå“åº”不含图形类型名，答案只在服务端），/api/auth/captcha èŽ·å–、/captcha/verify æ ¡éªŒï¼ˆé”™ 3 æ¬¡æ¢é¢˜ï¼‰ã€/login æ¶ˆè´¹ï¼ˆä¸€æ¬¡æ€§ï¼ŒæœªéªŒè¯ 4003/已过期 4002/顺序错 4001）；前端 Captcha3D.vue SVG æ¸²æŸ“（背景随机色+6 ç§å›¾æ¡ˆã€8 ç§ç«‹ä½“图形随机位置/大小/旋转/颜色），Login.vue æŽ¥å…¥çœŸå®žç™»å½•ï¼ˆaxios+token+localStorage），router åŠ ç™»å½•å®ˆå«ã€‚实测通过：正确顺序验证成功、错误顺序提示重试、未验证拦截、错密码 401、登录跳转工作台。坑：Vue2 ç»„件名大小写敏感，组件注册 Captcha3D æ—¶æ¨¡æ¿å¿…须写 <captcha3-d>（<captcha3d> ä¼šè¢«è§£æžæˆ Captcha3d åŒ¹é…ä¸ä¸Šï¼‰ã€‚
- 2026-08-27（续）：登录页视觉与登出——验证码画布 340x190 ç¼©ä¸º 340x148、图形 size 0.8~1.2 ç¼©ä¸º 0.6~0.95、间距/抖动收紧、旋转 Â±14°；登录卡片 420→400 å®½ã€form é—´è·æ”¶ç´§ï¼ˆå¡ç‰‡é«˜çº¦ 559px）。立方体/长方体改为斜二测教科书画法（前面正方形+顶/侧斜出，更立体）。新增公共 components/AppHeader.vue（标题+当前用户+退出登录，退出清 token å›žç™»å½•é¡µï¼‰ï¼Œæ›¿æ¢ 6 ä¸ªä¸šåŠ¡é¡µåŽŸæœ‰ el-header。坑：批量插入 components æ—¶ ExplainReview åŽŸæœ‰ components: { AiChatDialog } è¢«è¦†ç›–（重复键），需合并为 { AppHeader, AiChatDialog }。另：PowerShell åŒå¼•å·å­—符串里的反引号会被吞掉，写 markdown ä»£ç æ ‡è®°è¦é¿å…ã€‚
- 2026-08-27（续2）：六棱柱改为标准等轴测正六边形顶面+3 ä¾§é¢ï¼ˆæ­¤å‰é¡¶é¢è¿‡æ‰è®¤ä¸å‡ºï¼‰ï¼›çƒæ”¹ä¸ºå¾„向渐变（亮→暗，前端渲染器新增 radial æ¸å˜æ”¯æŒï¼Œgradient id ç”¨ shape id åŽ»é‡ï¼‰ã€‚修布局回归：AppHeader æ˜¯è‡ªå®šä¹‰ç»„件，el-container æ£€æµ‹ä¸åˆ° el-header å­ç»„件导致外层容器变成横向（系统名称+登出只占左侧 435px）——6 ä¸ªä¸šåŠ¡é¡µå¤–层容器显式加 direction="vertical" ä¿®å¤ï¼ˆä¸Šï¼šç³»ç»Ÿæ  å·¦æ ‡é¢˜å³ç”¨æˆ·+登出；下：左菜单右工作区）。坑：radialFaces æ–¹æ³•è¯¯æ”¾è¿› computed（Vue computed ä¸æŽ¥å—参数，s ä¸º undefined æŠ¥é”™ï¼‰ï¼Œé¡»æ”¾ methods；vue-loader ç¼–译缓存/浏览器启发式缓存（index.html æ— ç¼“存头）导致改代码后页面仍加载旧 chunk——vue.config.js devServer.headers åŠ  Cache-Control: no-store，测试时用未访问过的 host:port。

- 2026-08-27（续3，双方合并）：合并流程——① æˆ‘方改动先提交（验证码+登出+布局，commit å‰ç¼€ feat:）；② ä»Ž 08-23 åŸºçº¿
  å»º `partner-work` åˆ†æ”¯ï¼Œé•œåƒå¯¹æ–¹ç›®å½• `D:\03_公司\02_项目\27_湖北省道路运输事业发展中心\05_开发测试\00_开发\traffic-audit-project-20260827`
  ï¼ˆæŽ’除 .git/dist/日志/对方验证码相关文件：ShapeCaptcha.vue、security/captcha/*、CAPTCHA.md、cp.txt、t_test.js），提交为对方开发结果；
  â‘¢ `git merge partner-work` è§£å†³å†²çªï¼šLoginController=我方验证码+对方数据库校验（UserMapper+PasswordEncoder+modules/realName）；
  Login.vue=我方 Captcha3D ç‰ˆï¼ˆè¡¥å­˜ realName/modules）；router å®ˆå«ç”¨æˆ‘方版本；6 ä¸ªä¸šåŠ¡é¡µ=对方功能版+我方 AppHeader ä¸Šä¸‹å¸ƒå±€
  ï¼ˆæ ¹å®¹å™¨ direction="vertical"、el-header æ¢ app-header、删菜单内退出登录、注册 AppHeader ç»„件）；HANDOFF.md é‡å†™ä¸ºåˆå¹¶ç‰ˆã€‚
  â‘£ pom.xml åŽ»æŽ‰å¯¹æ–¹åŠ çš„ spring-boot-starter-data-redis（验证码用我方内存版，无需 Redis）；application.yml æœ¬åœ°åˆå¹¶
  ï¼ˆä¿ç•™æˆ‘æ–¹ 3305 æ•°æ®åº“参数，加 multipart 100MB、docs æ¨¡æ¿ç›®å½•é…ç½®ï¼›example æ¨¡æ¿åŒæ­¥ï¼‰ã€‚⑤ æ•°æ®åº“补齐（见第一节）；init.sql
  è¡¥ sys_user.modules åˆ—、修正 admin å¯†ç ä¸ºçœŸå®ž BCrypt、追加 passenger_individual_monthly ä¸Ž audit_run è¡¨ï¼›åŸŽå¸‚客运两个
  sql çš„规则 INSERT æ”¹å†™ä¸º INSERT IGNORE VALUES（兼容 MySQL 5.7/8.0，原派生表写法在 8.0.29 æŠ¥ Unknown column t.rule_code）。
  â‘¥ éªŒè¯ï¼šåŽç«¯ mvn compile âœ…、前端 npm run build âœ…。坑：链接工作区 .git æ˜¯æ–‡ä»¶ï¼Œrobocopy /MIR ä¼šæŠŠå®ƒåˆ æŽ‰å¯¼è‡´"not a git
  repository"，需重建 gitdir æ–‡ä»¶ï¼›PowerShell çš„ -e "..." å­—符串里 $ ä¼šè¢«å½“变量展开，写 SQL å¯†ç å“ˆå¸Œè¦ç”¨ SQL æ–‡ä»¶ã€‚

 check_h2032.py

File was deleted

 check_schema.py

File was deleted

 clear-bom.ps1

File was deleted

 cmp2.py

File was deleted

 cmp_reports.py

File was deleted

 cmp_xml.py

File was deleted

 docs/README.md

@@ -1,6 +1,6 @@
# äº¤é€šç»Ÿè®¡æŠ¥è¡¨å®¡æ ¸ç³»ç»Ÿ - Demo è¯´æ˜Ž

> Demo èŒƒå›´ï¼šäº¤ä¼ç»ŸH203-2表（道路货物运输月度生产情况）
> å·²å®žçŽ°ï¼šäº¤ä¼ç»ŸH203-2（道路货物运输月度生产情况）+ H203-1（公路旅客运输月度生产情况）
> éœ€æ±‚文档：`货运简化.docx`、`database.md`、`architecture.md`；数据库脚本：`init.sql`

## ä¸€ã€çŽ¯å¢ƒè¦æ±‚
@@ -10,12 +10,12 @@
| JDK | 1.8 |
| Maven | 3.x |
| Node.js | 14+（Vue CLI） |
| MySQL | 5.7（本机 `localhost:3305`，账号 `root/root`） |
| MySQL | 8.0（本机 `localhost:3308`，账号 `root/123456`，服务 MySQL80） |

## äºŒã€åˆå§‹åŒ–数据库

```bash
mysql --default-character-set=utf8mb4 -h localhost -P 3305 -u root -proot < docs/init.sql
mysql --default-character-set=utf8mb4 -h localhost -P 3308 -u root -p123456 < docs/init.sql
```

`init.sql` ä¼šé‡å»º `traffic_audit` åº“（含旧版表清理），并预置：

 docs/database.md

@@ -211,7 +211,99 @@
| import_batch_id | bigint | å¯¼å…¥æ‰¹æ¬¡ |
| created_at | datetime | åˆ›å»ºæ—¶é—´ |


### h2031_enterprise_monthly（交企统H203-1表 å…¬è·¯æ—…客运输月度生产情况）
> æ•°æ®æ¥æºï¼šå…¬è·¯æ—…客运输月度生产情况.xlsx çš„「公路旅客6月报」sheet；同文件「运政车辆数」sheet å¯¼å…¥ passenger_auth_vehicle

| å­—段 | ç±»åž‹ | è¯´æ˜Ž |
|------|------|------|
| id | bigint | PK |
| report_period | varchar(20) | æŠ¥è¡¨æœŸ 2026-06 |
| region_code | varchar(20) | æ‰€å±žåœ°åŒºï¼ˆè¡Œæ”¿åŒºåˆ’代码） |
| enterprise_code | varchar(50) | ä¼ä¸šä»£ç  |
| enterprise_name | varchar(200) | ä¼ä¸šåç§° |
| vehicle_total | int | å®¢è¿è½¦è¾†_总计 |
| seat_total | int | æ ¸å®šè½½å®¢ä½_总计 |
| vehicle_schedule | int | è½¦è¾†æ•°_客运班车（含定线旅游） |
| seat_schedule | int | æ ¸å®šè½½å®¢ä½_客运班车（含定线旅游） |
| vehicle_charter | int | è½¦è¾†æ•°_客运包车（含非定线旅游） |
| seat_charter | int | æ ¸å®šè½½å®¢ä½_客运包车（含非定线旅游） |
| passenger_total | double | å®¢è¿é‡_总计（人） |
| turnover_total | double | æ—…客周转量_总计（人公里） |
| passenger_class1 ~ passenger_class4 | double | å®¢è¿é‡_一~四类客运班线（含定线旅游） |
| turnover_class1 ~ turnover_class4 | double | æ—…客周转量_一~四类客运班线（含定线旅游） |
| passenger_charter | double | å®¢è¿é‡_客运包车（含非定线旅游） |
| turnover_charter | double | æ—…客周转量_客运包车（含非定线旅游） |
| avg_distance_total | double | å®¢è¿å¹³å‡è¿è·ï¼ˆå…¬é‡Œï¼‰ |
| avg_distance_class1 ~ avg_distance_class4 | double | ä¸€~四类客运班线平均运距（公里） |
| avg_distance_charter | double | æ—…游、包车平均运距（公里） |
| verify_explanation | text | æ ¸å®žæ€§åŽŸå› è§£é‡Š |
| import_batch_id | bigint | å¯¼å…¥æ‰¹æ¬¡ |
| created_at | datetime | åˆ›å»ºæ—¶é—´ |

### passenger_auth_vehicle（公路旅客运政车辆数据）
> æ•°æ®æ¥æºï¼šå…¬è·¯æ—…客运输月度生产情况.xlsx çš„「运政车辆数」sheet（企业代码/企业名称/车辆数/载客位数），随月报一起按报表期导入

| å­—段 | ç±»åž‹ | è¯´æ˜Ž |
|------|------|------|
| id | bigint | PK |
| report_period | varchar(20) | æŠ¥è¡¨æœŸ |
| enterprise_code | varchar(50) | ä¼ä¸šä»£ç  |
| enterprise_name | varchar(200) | ä¼ä¸šåç§° |
| vehicle_count | int | è½¦è¾†æ•° |
| seat_count | int | è½½å®¢ä½æ•° |
| import_batch_id | bigint | å¯¼å…¥æ‰¹æ¬¡ |
| created_at | datetime | åˆ›å»ºæ—¶é—´ |

---

### h204_vehicle_quarterly（交企统H204表 é“路货运车辆能源消耗情况·车辆粒度）
> æ•°æ®æ¥æºï¼šé“路货运车辆能源消耗情况（2026年）.xlsx çš„「第二季度货车能耗明细」sheet（每行左右各5组车辆、每组18列）；同文件「运政车辆信息」sheet å¯¼å…¥ h204_auth_vehicle

| å­—段 | ç±»åž‹ | è¯´æ˜Ž |
|------|------|------|
| id | bigint | PK |
| report_period | varchar(20) | æŠ¥è¡¨æœŸ 2026-06（季度末月） |
| region_code | varchar(20) | æ‰€å±žåœ°åŒºï¼ˆè¡Œæ”¿åŒºåˆ’代码） |
| enterprise_code | varchar(50) | ä¼ä¸šä»£ç  |
| enterprise_name | varchar(200) | ä¼ä¸šåç§° |
| plate_no | varchar(30) | è½¦ç‰Œå· |
| vehicle_type_code | varchar(10) | è½¦è¾†ç±»åž‹ä»£ç  |
| vehicle_type | varchar(50) | è½¦è¾†ç±»åž‹ï¼ˆä¸­æ–‡ï¼‰ |
| fuel_type_code | varchar(10) | ç‡ƒæ–™ç±»åž‹ä»£ç  |
| fuel_type | varchar(50) | ç‡ƒæ–™ç±»åž‹ï¼ˆä¸­æ–‡ï¼‰ |
| manufacture_year | int | å‡ºåŽ‚年份 |
| marked_tonnage | double | æ ‡è®°å¨ä½ï¼ˆå¨ï¼‰ |
| total_mileage | double | æ€»è¡Œç¨‹ï¼ˆå…¬é‡Œï¼‰ |
| loaded_mileage | double | è½½è´§é‡Œç¨‹ï¼ˆå…¬é‡Œï¼‰ |
| empty_mileage | double | ç©ºé©¶é‡Œç¨‹ï¼ˆå…¬é‡Œï¼‰ |
| freight | double | è´§è¿é‡ï¼ˆå¨ï¼‰ |
| turnover | double | è´§ç‰©å‘¨è½¬é‡ï¼ˆå¨å…¬é‡Œï¼‰ |
| trip_count | int | è¶Ÿæ¬¡æ•°ï¼ˆä¸ªï¼‰ |
| fuel_unit | varchar(20) | ç‡ƒæ–™1计量单位 |
| fuel_consumption | double | ç‡ƒæ–™1消耗量 |
| avg_distance | double | å¹³å‡è¿è·ï¼ˆå…¬é‡Œï¼‰ |
| avg_loaded_tonnage | double | å¹³å‡è½½è´§å¨ä½ï¼ˆå¨ï¼‰ |
| avg_trip_mileage | double | å•è¶Ÿå¹³å‡é‡Œç¨‹ï¼ˆå…¬é‡Œï¼‰ |
| fuel_per_100km | double | ç™¾å…¬é‡Œå•è€— |
| turnover_fuel | double | å‘¨è½¬é‡å•è€— |
| import_batch_id | bigint | å¯¼å…¥æ‰¹æ¬¡ |
| created_at | datetime | åˆ›å»ºæ—¶é—´ |

### h204_auth_vehicle（道路货运能耗_运政车辆信息）
> æ•°æ®æ¥æºï¼šé“路货运车辆能源消耗情况（2026年）.xlsx çš„「运政车辆信息」sheet（车牌号/车辆类型/燃料类型/标记吨位/准牵引质量），随季报一起按报表期导入

| å­—段 | ç±»åž‹ | è¯´æ˜Ž |
|------|------|------|
| id | bigint | PK |
| report_period | varchar(20) | æŠ¥è¡¨æœŸ |
| plate_no | varchar(30) | è½¦ç‰Œå· |
| vehicle_type | varchar(50) | è½¦è¾†ç±»åž‹ï¼ˆä¸­æ–‡ï¼‰ |
| fuel_type | varchar(50) | ç‡ƒæ–™ç±»åž‹ï¼ˆä¸­æ–‡ï¼‰ |
| marked_tonnage | double | æ ‡è®°å¨ä½ï¼ˆå¨ï¼‰ |
| traction_quality | double | å‡†ç‰µå¼•è´¨é‡ï¼ˆç‰µå¼•è½¦æ ‡è®°å¨ä½ï¼‰ |
| import_batch_id | bigint | å¯¼å…¥æ‰¹æ¬¡ |
| created_at | datetime | åˆ›å»ºæ—¶é—´ |

## ä¸‰ã€å®¡æ ¸è§„则模块

@@ -232,13 +324,25 @@
| sort_order | int | æŽ’序 |
| created_at | datetime | - |

Demo预置6条规则：
Demo预置14条规则（report_type åŒºåˆ† H2032 è´§è¿ / H2031 æ—…客）：

货运 H2032 6条：
1. è½¦è¾†è¿æ”¿å¯¹æ¯”（DIFF>5 â†’ RED）
2. å¨ä½è¿æ”¿å¯¹æ¯”（DIFF>50 â†’ RED）
3. å‘¨è½¬é‡è½¨è¿¹å¯¹æ¯”（RATIO>1.3 â†’ RED）
4. è´§è¿ç±»åž‹çŽ¯æ¯”（MOM â†’ YELLOW）
5. é›†è£…箱异常（NULL_CHECK â†’ RED）
6. æ•´è½¦å¨ä½èŒƒå›´ï¼ˆOUT_RANGE ä¸åœ¨4-40之间 â†’ YELLOW）

旅客 H2031 8条（compare_type æ–°å¢ž MOM_EQ_ZERO/MOM_PCT/MOM_EQ/EXISTENCE）：
1. è½¦è¾†æ•°è¿æ”¿å¯¹æ¯”（DIFF>3 â†’ RED）
2. è½½å®¢ä½æ•°è¿æ”¿å¯¹æ¯”（DIFF>50 â†’ RED）
3. å®¢è¿é‡çŽ¯æ¯”=0（一~四类+包车，值与上月相同 â†’ YELLOW）
4. æ—…客周转量环比=0（同上 â†’ YELLOW）
5. å¹³å‡è¿è·çŽ¯æ¯”超±10%（一~四类 â†’ YELLOW）
6. åŒ…车平均运距等于上月（→ YELLOW）
7. æ— ç­çº¿æœ‰ç­çº¿å®¢è¿é‡ï¼ˆEXISTENCE â†’ RED）
8. æ— åŒ…车有包车客运量（EXISTENCE â†’ RED）

## å››ã€å®¡æ ¸ç»“果模块

@@ -278,6 +382,7 @@
|------|------|------|
| ç”Ÿæˆ_货运量分市州明细.xlsx | freight_turnover_import + h2032_enterprise_monthly + scale_split_transport | 1-N月明细+同比；货运量合计=模板、规上=H2032、规下=合计-规上；周转量=拆分表 |
| ç”Ÿæˆ_货运量排名.xlsx | freight_turnover_import + h2032_enterprise_monthly | è§„上=H2032累计、合计=模板累计、规下=合计-规上 |
| ç”Ÿæˆ_公路旅客分市州明细.xlsx | h2031_enterprise_monthly（按市州汇总） | æœˆæŠ¥ï¼ˆé€‰å¹´-月，今年1-N月+累计）/年报（选年份，全年12个月+累计）；每期含当年+近3年区块、各月同比、累计同比；城际城乡公交/巡游出租/网约车列暂留空 |
| ç”Ÿæˆ_周转量排名.xlsx | scale_split_transport | è§„上/规下/合计周转量排名（含忠实导入的全省行） |

## å…­ã€ç³»ç»Ÿæ—¥å¿—
@@ -314,3 +419,65 @@
| masked_value | varchar(200) | è„±æ•å€¼ |
| mask_type | varchar(20) | ENTERPRISE/REGION |
| call_id | varchar(50) | è°ƒç”¨ID |

## å…«ã€æŠ•èµ„模块（客运站场 / ç‰©æµå›­åŒºï¼‰

> æ•°æ®æºï¼šå…¨çœæ±‡æ€»å¤§è¡¨ï¼ˆ`7月客运站投资明细表.xlsx` æ˜Žç»†sheet、`6月物流站场投资明细.xls` åˆ†é¡¹ç›®æŠ•èµ„完成情况sheet），审核比对基准为投资系统导出（`查询结果(投资系统-客运+物流 2026.7).xls`）。

### investment_project（投资项目主档）
| å­—段 | ç±»åž‹ | è¯´æ˜Ž |
|------|------|------|
| id | bigint | PK |
| project_name | varchar(200) | é¡¹ç›®åç§°ï¼ˆä¸Ž category ç»„成唯一键） |
| category | varchar(20) | å®¢è¿ç«™åœº / ç‰©æµå›­åŒº |
| city | varchar(50) | å¸‚å·ž |
| county | varchar(100) | åŽ¿ï¼ˆå¸‚、区） |
| builder_name | varchar(200) | æŠ•èµ„建设单位 |
| construct_nature | varchar(50) | å»ºè®¾æ€§è´¨ï¼ˆæ–°å»º/续建/改扩建） |
| start_time / end_time | varchar(20) | å¼€å·¥ / å»ºæˆæ—¶é—´ |
| total_investment | double | è®¡åˆ’总投资（万元） |
| approval_gk / approval_cs | varchar(500) | å·¥å¯ / åˆè®¾æ‰¹å¤ |
| building_area | double | å»ºç­‘面积（平方米，物流表） |
| is_billion / is_county / is_five_year | tinyint | äº¿å…ƒ / ç»æµŽå¼ºåŽ¿ / åäº”五重点 å›ºå®šåå•æ ‡è®° |

### investment_monthly（投资项目月度完成情况）
| å­—段 | ç±»åž‹ | è¯´æ˜Ž |
|------|------|------|
| id | bigint | PK |
| report_period | varchar(20) | æŠ¥è¡¨æœŸ 2026-07 |
| project_id | bigint | å…³è” investment_project.id |
| year_plan | double | æœ¬å¹´è®¡åˆ’投资（万元） |
| year_cum | double | è‡ªå¹´åˆç´¯è®¡å®ŒæˆæŠ•èµ„（万元） |
| month_done | double | å…¶ä¸­ï¼šæœ¬æœˆå®ŒæˆæŠ•èµ„（万元） |
| start_cum | double | è‡ªå¼€å§‹å»ºè®¾ç´¯è®¡å®ŒæˆæŠ•èµ„（万元） |
| progress_stage | varchar(100) | å»ºè®¾é˜¶æ®µ |
| progress_desc | varchar(2000) | å½¢è±¡è¿›åº¦ |
| building_area | double | å»ºç­‘面积（平方米） |

### investment_system（投资系统导出·审核比对基准）
| å­—段 | ç±»åž‹ | è¯´æ˜Ž |
|------|------|------|
| id | bigint | PK |
| report_period | varchar(20) | æŠ¥è¡¨æœŸ |
| project_name | varchar(200) | é¡¹ç›®åç§°ï¼ˆå•ä½ï¼‰ |
| total_investment | double | è®¡åˆ’总投资（万元） |
| start_cum | double | è‡ªå¼€å§‹å»ºè®¾è‡³æœ¬æœˆç´¯è®¡å®ŒæˆæŠ•èµ„（万元） |
| year_plan | double | æœ¬å¹´è®¡åˆ’投资（万元） |
| year_cum | double | è‡ªå¹´åˆç´¯è®¡å®ŒæˆæŠ•èµ„（万元） |
| month_done | double | å½“月完成投资（万元） |

### æŠ•èµ„审核规则（report_type=INVEST）
| è§„则 | æ¯”较类型 | è¯´æ˜Ž |
|------|---------|------|
| RULE_I001 è‡ªå¼€å§‹ç´¯è®¡å¯¹æ¯” | CROSS_DIFF | ç»å¯¹å·®>100万 ä¸” ç›¸å¯¹å·®>5% |
| RULE_I002 è‡ªå¹´åˆç´¯è®¡å¯¹æ¯” | CROSS_DIFF | ç»å¯¹å·®>50万 ä¸” ç›¸å¯¹å·®>5% |
| RULE_I003 æœ¬æœˆå®Œæˆå¯¹æ¯” | CROSS_DIFF | ç»å¯¹å·®>30万 ä¸” ç›¸å¯¹å·®>30% |
| RULE_I004 ç³»ç»Ÿç¼ºå¤± | EXISTENCE_SYS | æ±‡æ€»å¤§è¡¨é¡¹ç›®åœ¨æŠ•èµ„系统导出中不存在 |

### æŠ•èµ„ 4 å¼ é¢†å¯¼æŠ¥è¡¨ï¼ˆReportExportService）
| ç«¯ç‚¹ | è¡¨å | æ•°æ® |
|------|------|------|
| /api/report/export/investPlan | å…¨çœé¢„安排计划进度汇总 | å®¢è¿+物流大块、17市州小节+项目行 |
| /api/report/export/investFiveYearLogistics | "十五五"物流项目进展 | å›ºå®šåå•è¿‡æ»¤ï¼Œå¸‚州小节+项目行 |
| /api/report/export/investBillion | äº¿å…ƒæŠ•èµ„项目 | æŠ•èµ„总表 + è§„上项目表两sheet，亿元名单过滤 |
| /api/report/export/investCounty | ç»æµŽå¼ºåŽ¿æŠ•èµ„统计 | ç»æµŽå¼ºåŽ¿åå•è¿‡æ»¤ |

 docs/init.sql

@@ -37,6 +37,7 @@
    username VARCHAR(50) NOT NULL UNIQUE,
    password VARCHAR(200) NOT NULL COMMENT 'BCrypt',
    real_name VARCHAR(50),
    modules VARCHAR(255) DEFAULT NULL COMMENT '负责报表模块（逗号分隔）',
    phone VARCHAR(20),
    dept_id BIGINT,
    status TINYINT DEFAULT 1 COMMENT '0禁用 1启用',
@@ -289,7 +290,7 @@
('车辆数运政对比', 'RULE_001', '企业上报车辆数与运政数据对比，差距>5台需核实', 'vehicleTotal', 'DIFF', '5', 'RED', 'H2032', 1, 1),
('吨位运政对比', 'RULE_002', '企业上报吨位与运政数据对比，差距>50需核实', 'tonsTotal', 'DIFF', '50', 'RED', 'H2032', 1, 2),
('周转量轨迹对比', 'RULE_003', '上报周转量与轨迹测算周转量对比，高出30%需核实', 'turnoverTotal,trackMileage', 'RATIO', '1.3', 'RED', 'H2032', 1, 3),
('货运类型环比', 'RULE_004', '本月新增货运类型需核实', 'freightContainer,freightCoal', 'MOM', '0', 'YELLOW', 'H2032', 1, 4),
('货运类型环比', 'RULE_004', '本月新增货运类型需核实（上月为0、本月有量）', 'freightContainer,freightCoal,freightOilGas,freightCrudeOil,freightMetalOre,freightIronOre,freightBuilding,freightGrain', 'MOM', '0', 'YELLOW', 'H2032', 1, 4),
('集装箱异常', 'RULE_005', '无集装箱车但有集装箱货运量需核实', 'freightContainer,vehicleContainer', 'NULL_CHECK', '0', 'RED', 'H2032', 1, 5),
('整车吨位范围', 'RULE_006', '整车吨位不在4-40吨之间', 'tonsWhole', 'OUT_RANGE', '4,40', 'YELLOW', 'H2032', 1, 6);

@@ -382,6 +383,237 @@

-- é¢„置管理员账号 admin / admin123
INSERT INTO sys_user (username, password, real_name, dept_id) VALUES
('admin', '.zmdr9k7uOCQb376NoUnuTJ8iAt6Z5EHsM8lE9lBOsl7iAt6Z5Eh', '系统管理员', 1);
('admin', '$2b$10$aqN02Pwvzzuta/66V9MpGerfUH6favtq8av3cc/gueg6lQ9E4CH8u', '系统管理员', 1);

INSERT INTO sys_user_role (user_id, role_id) VALUES (1, 1);


-- ============================================
-- å…«ã€å…¬è·¯æ—…客运输（交企统H203-1）扩展模块
-- ============================================

DROP TABLE IF EXISTS h2031_enterprise_monthly;
CREATE TABLE h2031_enterprise_monthly (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    report_period VARCHAR(20) NOT NULL COMMENT '报表期 2026-06',
    region_code VARCHAR(20) COMMENT '所属地区',
    enterprise_code VARCHAR(50) COMMENT '企业代码',
    enterprise_name VARCHAR(200) COMMENT '企业名称',
    vehicle_total INT COMMENT '客运车辆_总计',
    seat_total INT COMMENT '核定载客位_总计',
    vehicle_schedule INT COMMENT '车辆数_客运班车（含定线旅游客运客车）',
    seat_schedule INT COMMENT '核定载客位_客运班车（含定线旅游客运客车）',
    vehicle_charter INT COMMENT '车辆数_客运包车（含非定线旅游客运客车）',
    seat_charter INT COMMENT '核定载客位_客运包车（含非定线旅游客运客车）',
    passenger_total DOUBLE COMMENT '客运量_总计（人）',
    turnover_total DOUBLE COMMENT '旅客周转量_总计（人公里）',
    passenger_class1 DOUBLE COMMENT '客运量_一类客运班线（含定线旅游）',
    turnover_class1 DOUBLE COMMENT '旅客周转量_一类客运班线（含定线旅游）',
    passenger_class2 DOUBLE COMMENT '客运量_二类客运班线（含定线旅游）',
    turnover_class2 DOUBLE COMMENT '旅客周转量_二类客运班线（含定线旅游）',
    passenger_class3 DOUBLE COMMENT '客运量_三类客运班线（含定线旅游）',
    turnover_class3 DOUBLE COMMENT '旅客周转量_三类客运班线（含定线旅游）',
    passenger_class4 DOUBLE COMMENT '客运量_四类客运班线（含定线旅游）',
    turnover_class4 DOUBLE COMMENT '旅客周转量_四类客运班线（含定线旅游）',
    passenger_charter DOUBLE COMMENT '客运量_客运包车（含非定线旅游）',
    turnover_charter DOUBLE COMMENT '旅客周转量_客运包车（含非定线旅游）',
    avg_distance_total DOUBLE COMMENT '客运平均运距（公里）',
    avg_distance_class1 DOUBLE COMMENT '一类客运班线平均运距（公里）',
    avg_distance_class2 DOUBLE COMMENT '二类客运班线平均运距（公里）',
    avg_distance_class3 DOUBLE COMMENT '三类客运班线平均运距（公里）',
    avg_distance_class4 DOUBLE COMMENT '四类客运班线平均运距（公里）',
    avg_distance_charter DOUBLE COMMENT '旅游、包车平均运距（公里）',
    verify_explanation TEXT COMMENT '核实性原因解释',
    import_batch_id BIGINT COMMENT '导入批次',
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='交企统H203-1表_公路旅客运输月度生产情况';

DROP TABLE IF EXISTS passenger_auth_vehicle;
CREATE TABLE passenger_auth_vehicle (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    report_period VARCHAR(20) COMMENT '报表期',
    enterprise_code VARCHAR(50) COMMENT '企业代码',
    enterprise_name VARCHAR(200) COMMENT '企业名称',
    vehicle_count INT DEFAULT 0 COMMENT '车辆数',
    seat_count INT DEFAULT 0 COMMENT '载客位数',
    import_batch_id BIGINT COMMENT '导入批次',
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='公路旅客运政车辆数据';

-- H203-1 é¢„置审核规则（4组8条，report_type=H2031）
INSERT INTO audit_rule (rule_name, rule_code, description, check_field, compare_type, threshold, alert_level, report_type, is_enabled, sort_order) VALUES
('车辆数运政对比(旅客)', 'RULE_P001', '客运车辆数与运政车辆数对比，差距>3台需核实', 'vehicleTotal', 'DIFF', '3', 'RED', 'H2031', 1, 21),
('载客位数运政对比(旅客)', 'RULE_P002', '核定载客位数与运政载客位数对比，差距>50需核实', 'seatTotal', 'DIFF', '50', 'RED', 'H2031', 1, 22),
('客运量环比=0核实', 'RULE_P003', '一类/二类/三类/四类/包车客运量环比上个月等于0需核实', 'passengerClass1,passengerClass2,passengerClass3,passengerClass4,passengerCharter', 'MOM_EQ_ZERO', '0', 'YELLOW', 'H2031', 1, 23),
('旅客周转量环比=0核实', 'RULE_P004', '一类/二类/三类/四类/包车旅客周转量环比上个月等于0需核实', 'turnoverClass1,turnoverClass2,turnoverClass3,turnoverClass4,turnoverCharter', 'MOM_EQ_ZERO', '0', 'YELLOW', 'H2031', 1, 24),
('平均运距环比超±10%核实', 'RULE_P005', '一类/二类/三类/四类平均运距环比上个月超过±10%需核实', 'avgDistanceClass1,avgDistanceClass2,avgDistanceClass3,avgDistanceClass4', 'MOM_PCT', '10', 'YELLOW', 'H2031', 1, 25),
('包车平均运距等于上月核实', 'RULE_P006', '旅游包车平均运距等于上个月需核实', 'avgDistanceCharter', 'MOM_EQ', '0', 'YELLOW', 'H2031', 1, 26),
('无班线有班线客运量核实', 'RULE_P007', '无客运班车（班线车辆数为0）但有班线客运量需核实', 'vehicleSchedule,passengerClass1,passengerClass2,passengerClass3,passengerClass4', 'EXISTENCE', '0', 'RED', 'H2031', 1, 27),
('无包车有包车客运量核实', 'RULE_P008', '无客运包车（包车车辆数为0）但有包车客运量需核实', 'vehicleCharter,passengerCharter', 'EXISTENCE', '0', 'RED', 'H2031', 1, 28);


-- ============================================
-- ä¹ã€é“路货运能源消耗（交企统H204）扩展模块
-- ============================================

-- é“路货运车辆能源消耗情况（车辆粒度季报）
DROP TABLE IF EXISTS h204_vehicle_quarterly;
CREATE TABLE h204_vehicle_quarterly (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    report_period VARCHAR(20) NOT NULL COMMENT '报表期 2026-06（季度末月）',
    region_code VARCHAR(20) COMMENT '所属地区',
    enterprise_code VARCHAR(50) COMMENT '企业代码',
    enterprise_name VARCHAR(200) COMMENT '企业名称',
    plate_no VARCHAR(30) COMMENT '车牌号',
    vehicle_type_code VARCHAR(10) COMMENT '车辆类型代码',
    vehicle_type VARCHAR(50) COMMENT '车辆类型（中文）',
    fuel_type_code VARCHAR(10) COMMENT '燃料类型代码',
    fuel_type VARCHAR(50) COMMENT '燃料类型（中文）',
    manufacture_year INT COMMENT '出厂年份',
    marked_tonnage DOUBLE COMMENT '标记吨位（吨）',
    total_mileage DOUBLE COMMENT '总行程（公里）',
    loaded_mileage DOUBLE COMMENT '载货里程（公里）',
    empty_mileage DOUBLE COMMENT '空驶里程（公里）',
    freight DOUBLE COMMENT '货运量（吨）',
    turnover DOUBLE COMMENT '货物周转量（吨公里）',
    trip_count INT COMMENT '趟次数（个）',
    fuel_unit VARCHAR(20) COMMENT '燃料1计量单位',
    fuel_consumption DOUBLE COMMENT '燃料1消耗量',
    avg_distance DOUBLE COMMENT '平均运距（公里）',
    avg_loaded_tonnage DOUBLE COMMENT '平均载货吨位（吨）',
    avg_trip_mileage DOUBLE COMMENT '单趟平均里程（公里）',
    fuel_per_100km DOUBLE COMMENT '百公里单耗',
    turnover_fuel DOUBLE COMMENT '周转量单耗',
    import_batch_id BIGINT COMMENT '导入批次',
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    KEY idx_period_plate (report_period, plate_no),
    KEY idx_period_ent (report_period, enterprise_code)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='交企统H204表_道路货运车辆能源消耗情况（车辆粒度）';

-- é“路货运能耗_运政车辆信息（车牌粒度）
DROP TABLE IF EXISTS h204_auth_vehicle;
CREATE TABLE h204_auth_vehicle (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    report_period VARCHAR(20) NOT NULL COMMENT '报表期',
    plate_no VARCHAR(30) NOT NULL COMMENT '车牌号',
    vehicle_type VARCHAR(50) COMMENT '车辆类型',
    fuel_type VARCHAR(50) COMMENT '燃料类型',
    marked_tonnage DOUBLE COMMENT '标记吨位（吨）',
    traction_quality DOUBLE COMMENT '准牵引质量（牵引车标记吨位）',
    import_batch_id BIGINT COMMENT '导入批次',
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    KEY idx_period_plate (report_period, plate_no)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='道路货运能耗_运政车辆信息（车牌粒度）';

-- H204 é¢„置审核规则（4条，report_type=H204）
INSERT INTO audit_rule (rule_name, rule_code, description, check_field, compare_type, threshold, alert_level, report_type, is_enabled, sort_order) VALUES
('车辆类型与运政对比', 'RULE_E001', '能耗明细车辆类型与运政车辆信息不一致需核实', 'vehicleType', 'CROSS_DIFF', '0', 'RED', 'H204', 1, 31),
('燃料类型与运政对比', 'RULE_E002', '能耗明细燃料类型与运政车辆信息不一致需核实', 'fuelType', 'CROSS_DIFF', '0', 'RED', 'H204', 1, 32),
('标记吨位与运政对比', 'RULE_E003', '能耗明细标记吨位与运政对比，差距>0.05吨需核实（牵引车对比准牵引质量）', 'markedTonnage', 'CROSS_DIFF', '0.05', 'YELLOW', 'H204', 1, 33),
('运政车辆信息缺失', 'RULE_E004', '能耗明细车牌号在运政车辆信息中不存在需核实', 'plateNo', 'EXISTENCE_AUTH', '0', 'RED', 'H204', 1, 34),
('载货里程占比与单趟里程比核实', 'RULE_E005', '载货里程/总行程 ä¸Ž å¹³å‡è¿è·/单趟平均里程 ç›¸å·®Â±10%需核实', 'loadedMileage,totalMileage,avgDistance,avgTripMileage', 'LOADED_RATIO_DIFF', '0.1', 'YELLOW', 'H204', 1, 35),
('百公里单耗超范围核实', 'RULE_E006', '百公里单耗偏离同燃料类型中位数超过50%需核实', 'fuelPer100km,fuelTypeCode', 'FUEL_RANGE', '0.5', 'YELLOW', 'H204', 1, 36),
('百公里单耗环比变化核实', 'RULE_E007', '同一辆车百公里单耗环比变化超过±50%需核实', 'fuelPer100km,plateNo', 'FUEL_MOM', '0.5', 'YELLOW', 'H204', 1, 37),
('能耗量与货运月报对比核实', 'RULE_E008', '企业能耗货运量/周转量之和大于货运月报50%需核实', 'freight,turnover,enterpriseName', 'FREIGHT_VS_H2032', '0.5', 'RED', 'H204', 1, 38),
('平均运距与货运月报对比核实', 'RULE_E009', '车辆平均运距与货运月报平均运距相差±60%需核实', 'avgDistance,enterpriseName', 'AVG_DIST_VS_H2032', '0.6', 'YELLOW', 'H204', 1, 39),
('平均载货吨位与标记吨位比值核实', 'RULE_E010', '平均载货吨位/标记吨位 å°äºŽ0.5或大于1需核实', 'avgLoadedTonnage,markedTonnage', 'LOADED_TON_RATIO', '0.5,1', 'YELLOW', 'H204', 1, 40);

-- ============================================
-- åã€æŠ•èµ„模块（客运站场/物流园区）扩展
-- ============================================

-- æŠ•èµ„项目主档（按 é¡¹ç›®å+类别 å”¯ä¸€ï¼‰
DROP TABLE IF EXISTS investment_project;
CREATE TABLE investment_project (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    project_name VARCHAR(200) NOT NULL COMMENT '项目名称',
    category VARCHAR(20) NOT NULL COMMENT '类别：客运站场/物流园区',
    city VARCHAR(50) COMMENT '市州',
    county VARCHAR(100) COMMENT '县（市、区）',
    builder_name VARCHAR(200) COMMENT '投资建设单位',
    construct_nature VARCHAR(50) COMMENT '建设性质',
    start_time VARCHAR(20) COMMENT '开工时间',
    end_time VARCHAR(20) COMMENT '建成/竣工时间',
    total_investment DOUBLE COMMENT '计划总投资（万元）',
    approval_gk VARCHAR(500) COMMENT '工可批复',
    approval_cs VARCHAR(500) COMMENT '初设批复',
    building_area DOUBLE COMMENT '建筑面积（平方米）',
    is_billion TINYINT DEFAULT 0 COMMENT '亿元投资项目标记',
    is_county TINYINT DEFAULT 0 COMMENT '经济强县项目标记',
    is_five_year TINYINT DEFAULT 0 COMMENT '十五五重点物流项目标记',
    source VARCHAR(50) COMMENT '数据来源',
    import_batch_id BIGINT COMMENT '导入批次',
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    UNIQUE KEY uk_name_category (project_name, category)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='投资项目主档';

-- æŠ•èµ„项目月度完成情况
DROP TABLE IF EXISTS investment_monthly;
CREATE TABLE investment_monthly (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    report_period VARCHAR(20) NOT NULL COMMENT '报表期 2026-07',
    project_id BIGINT NOT NULL COMMENT '项目主档ID',
    year_plan DOUBLE COMMENT '本年计划投资（万元）',
    year_cum DOUBLE COMMENT '自年初累计完成投资（万元）',
    month_done DOUBLE COMMENT '其中：本月完成投资（万元）',
    start_cum DOUBLE COMMENT '自开始建设累计完成投资（万元）',
    progress_stage VARCHAR(100) COMMENT '建设阶段',
    progress_desc VARCHAR(2000) COMMENT '形象进度',
    building_area DOUBLE COMMENT '建筑面积（平方米）',
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    KEY idx_period (report_period),
    KEY idx_project (project_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='投资项目月度完成情况';

-- æŠ•èµ„系统查询导出（审核比对基准）
DROP TABLE IF EXISTS investment_system;
CREATE TABLE investment_system (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    report_period VARCHAR(20) NOT NULL COMMENT '报表期 2026-07',
    project_name VARCHAR(200) NOT NULL COMMENT '项目名称（单位）',
    total_investment DOUBLE COMMENT '计划总投资（万元）',
    start_cum DOUBLE COMMENT '自开始建设至本月累计完成投资（万元）',
    year_plan DOUBLE COMMENT '本年计划投资（万元）',
    year_cum DOUBLE COMMENT '自年初累计完成投资（万元）',
    month_done DOUBLE COMMENT '当月完成投资（万元）',
    import_batch_id BIGINT COMMENT '导入批次',
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    KEY idx_period (report_period)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='投资系统查询导出（审核比对基准）';

-- INVEST é¢„置审核规则（4条，report_type=INVEST）
INSERT INTO audit_rule (rule_name, rule_code, description, check_field, compare_type, threshold, alert_level, report_type, is_enabled, sort_order) VALUES
('自开始累计与投资系统对比', 'RULE_I001', '自开始建设累计完成投资与投资系统导出差异超阈值需核实', 'startCum', 'CROSS_DIFF', '100|5', 'YELLOW', 'INVEST', 1, 41),
('自年初累计与投资系统对比', 'RULE_I002', '自年初累计完成投资与投资系统导出差异超阈值需核实', 'yearCum', 'CROSS_DIFF', '50|5', 'YELLOW', 'INVEST', 1, 42),
('本月完成与投资系统对比', 'RULE_I003', '本月完成投资与投资系统导出差异超阈值需核实', 'monthDone', 'CROSS_DIFF', '30|30', 'YELLOW', 'INVEST', 1, 43),
('投资系统项目缺失核实', 'RULE_I004', '汇总大表项目在投资系统导出中不存在需核实', 'projectName', 'EXISTENCE_SYS', '0', 'YELLOW', 'INVEST', 1, 44);


-- ============================================
-- ä¹ã€å…¬è·¯æ—…客个体客运量/周转量（企业线下汇报）
-- ============================================
DROP TABLE IF EXISTS passenger_individual_monthly;
CREATE TABLE passenger_individual_monthly (
  id BIGINT AUTO_INCREMENT PRIMARY KEY,
  report_period VARCHAR(20) COMMENT '报表期 2026-07',
  region_code VARCHAR(20) COMMENT '所属地区（行政区划代码）',
  enterprise_code VARCHAR(50) COMMENT '企业代码',
  enterprise_name VARCHAR(200) COMMENT '企业名称',
  passenger_count DOUBLE COMMENT '其中个体客运量（人）',
  turnover DOUBLE COMMENT '其中个体旅客周转量（人公里）',
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
  KEY idx_period (report_period)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='公路旅客个体客运量/周转量';

-- ============================================
-- åã€æŠ¥è¡¨æœŸå®¡æ ¸é€šè¿‡æ ‡è®°ï¼ˆaudit_run）
-- ============================================
DROP TABLE IF EXISTS audit_run;
CREATE TABLE audit_run (
  id BIGINT AUTO_INCREMENT PRIMARY KEY,
  report_type VARCHAR(50) COMMENT '报表类型',
  report_period VARCHAR(20) COMMENT '报表期',
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
  KEY idx_type_period (report_type, report_period)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='报表期审核通过标记';

 docs/sql_city_bus.sql

New file
@@ -0,0 +1,59 @@
-- åŸŽå¸‚客运第1步（公交）建表 + å®¡æ ¸è§„则
-- æ•°æ®æºï¼šå¯¼å…¥_城市公共交通月度运营情况（2026å¹´7月）.xls（企业级明细，含公共汽电车/轨道/轮渡三类，本表只取公共汽电车字段）

CREATE TABLE IF NOT EXISTS city_bus_monthly (
  id BIGINT NOT NULL AUTO_INCREMENT,
  report_period VARCHAR(20) NOT NULL COMMENT '报表期 2026-07',
  region_code VARCHAR(20) DEFAULT NULL COMMENT '所属地区代码',
  city VARCHAR(50) DEFAULT NULL COMMENT '市州（由地区代码映射）',
  enterprise_code VARCHAR(50) DEFAULT NULL COMMENT '企业代码',
  enterprise_name VARCHAR(200) DEFAULT NULL COMMENT '企业名称',
  op_vehicles DOUBLE DEFAULT NULL COMMENT '公共汽电车运营车数',
  stop_total DOUBLE DEFAULT NULL COMMENT '运营站点总个数',
  stop_city DOUBLE DEFAULT NULL COMMENT '其中：城市内运营站点',
  passenger_volume DOUBLE DEFAULT NULL COMMENT '公共汽电车客运量（万人次）',
  passenger_city DOUBLE DEFAULT NULL COMMENT '其中：城市内客运量（万人次）',
  turnover DOUBLE DEFAULT NULL COMMENT '公共汽电车旅客周转量（万人公里）',
  turnover_city DOUBLE DEFAULT NULL COMMENT '其中：城市内旅客周转量（万人公里）',
  avg_distance DOUBLE DEFAULT NULL COMMENT '公共汽电车平均运距（公里）',
  avg_distance_city DOUBLE DEFAULT NULL COMMENT '城市内平均运距（公里）',
  passenger_chengxiang DOUBLE DEFAULT NULL COMMENT '城际城乡客运量（万人次）',
  turnover_chengxiang DOUBLE DEFAULT NULL COMMENT '城际城乡旅客周转量（万人公里）',
  avg_distance_chengxiang DOUBLE DEFAULT NULL COMMENT '城际城乡平均运距（公里）',
  rate_op_vehicles_mom DOUBLE DEFAULT NULL COMMENT '运营车数环比增速',
  rate_passenger_mom DOUBLE DEFAULT NULL COMMENT '客运量环比增速',
  rate_passenger_city_mom DOUBLE DEFAULT NULL COMMENT '城市内客运量环比',
  rate_chengxiang_mom DOUBLE DEFAULT NULL COMMENT '城际城乡客运量环比增速',
  rate_chengxiang_turnover_mom DOUBLE DEFAULT NULL COMMENT '城际城乡旅客周转量环比增速',
  rate_turnover_mom DOUBLE DEFAULT NULL COMMENT '旅客周转量环比增速',
  avg_distance_mom_change DOUBLE DEFAULT NULL COMMENT '平均运距环比增减（公里）',
  avg_distance_city_mom_change DOUBLE DEFAULT NULL COMMENT '城市内平均运距环比增减（公里）',
  daily_passenger_per_vehicle DOUBLE DEFAULT NULL COMMENT '单车日均客运量',
  rate_op_vehicles_yoy DOUBLE DEFAULT NULL COMMENT '运营车数同比增速',
  rate_passenger_yoy DOUBLE DEFAULT NULL COMMENT '客运量同比增速',
  rate_passenger_city_yoy DOUBLE DEFAULT NULL COMMENT '城市内客运量同比增速',
  rate_chengxiang_yoy DOUBLE DEFAULT NULL COMMENT '城际城乡客运量同比增速',
  rate_chengxiang_turnover_yoy DOUBLE DEFAULT NULL COMMENT '城际城乡旅客周转量同比增速',
  rate_turnover_yoy DOUBLE DEFAULT NULL COMMENT '旅客周转量同比增速',
  stop_city_ratio DOUBLE DEFAULT NULL COMMENT '城市内运营站点占比',
  passenger_city_ratio DOUBLE DEFAULT NULL COMMENT '城市内客运量占比',
  chengxiang_ratio DOUBLE DEFAULT NULL COMMENT '城际城乡客运量占比',
  contact_person VARCHAR(100) DEFAULT NULL COMMENT '填表人',
  contact_phone VARCHAR(50) DEFAULT NULL COMMENT '联系电话',
  report_date VARCHAR(20) DEFAULT NULL COMMENT '报出日期',
  verify_explanation TEXT COMMENT '核实性原因解释',
  report_note TEXT COMMENT '上报说明',
  modify_record TEXT COMMENT '修改记录',
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (id),
  KEY idx_period (report_period),
  KEY idx_city (city),
  KEY idx_enterprise (enterprise_name)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='城市公交企业月度数据（城市公共交通月度运营情况）';

-- åŸŽå¸‚公交 4 ç»„审核规则（report_type=CITY_BUS）
INSERT IGNORE INTO audit_rule (rule_name, rule_code, description, check_field, compare_type, threshold, alert_level, report_type, is_enabled, sort_order) VALUES
  ('城市内与城际城乡客运量趋势一致核实', 'RULE_B001', '城市内客运量环比/同比与城际城乡客运量环比/同比趋势不一致且增速>2%需核实', 'passengerCityMom,passengerChengxiangMom,passengerCityYoy,passengerChengxiangYoy', 'TREND_CONSISTENCY', '0.02', 'YELLOW', 'CITY_BUS', 1, 51),
  ('客运量与旅客周转量趋势一致核实', 'RULE_B002', '客运量同比/环比与旅客周转量同比/环比趋势不一致需核实', 'passengerMom,turnoverMom,passengerYoy,turnoverYoy', 'TREND_CONSISTENCY', '0.02', 'YELLOW', 'CITY_BUS', 1, 52),
  ('城市内/城际城乡客运量占比变化核实', 'RULE_B003', '城市内客运量占比和城际城乡客运量占比与上月相比变化>1%需核实', 'passengerCityRatio,chengxiangRatio', 'RATIO_CHANGE', '0.01', 'YELLOW', 'CITY_BUS', 1, 53),
  ('平均运距变化幅度核实', 'RULE_B004', '平均运距与上月相比变化幅度超过3公里需核实（特别是城际城乡）', 'avgDistanceMomChange,avgDistanceCityMomChange,avgDistanceChengxiang', 'AVG_DIST_CHANGE', '3', 'YELLOW', 'CITY_BUS', 1, 54);

 docs/sql_city_taxi.sql

New file
@@ -0,0 +1,82 @@
-- åŸŽå¸‚客运第2步（巡游出租）建表 + å®¡æ ¸è§„则
-- æ•°æ®æº1：导入_巡游出租汽车运营服务情况月报（2026å¹´7月）.xls（市州级，17行）
-- æ•°æ®æº2：输入_出租车信息(运政车辆信息).xls（车辆级明细 42636 è¡Œï¼‰

CREATE TABLE IF NOT EXISTS city_taxi_monthly (
  id BIGINT NOT NULL AUTO_INCREMENT,
  report_period VARCHAR(20) NOT NULL COMMENT '报表期 2026-07',
  region_code VARCHAR(20) DEFAULT NULL COMMENT '所属地区代码',
  city VARCHAR(50) DEFAULT NULL COMMENT '市州',
  trip_total DOUBLE DEFAULT NULL COMMENT '载客车次总数',
  trip_city DOUBLE DEFAULT NULL COMMENT '载客车次总数_城市内',
  passenger_volume DOUBLE DEFAULT NULL COMMENT '客运量（万人次）',
  passenger_city DOUBLE DEFAULT NULL COMMENT '客运量_其中城市内',
  turnover DOUBLE DEFAULT NULL COMMENT '旅客周转量（万人公里）',
  turnover_city DOUBLE DEFAULT NULL COMMENT '旅客周转量_城市内',
  op_vehicles DOUBLE DEFAULT NULL COMMENT '运营车辆数',
  avg_distance DOUBLE DEFAULT NULL COMMENT '巡游出租汽车平均运距（公里）',
  avg_distance_city DOUBLE DEFAULT NULL COMMENT '城市内平均运距（公里）',
  daily_trips_per_vehicle DOUBLE DEFAULT NULL COMMENT '单车日均载客车次',
  daily_passenger_per_vehicle DOUBLE DEFAULT NULL COMMENT '单车日均客运量',
  passengers_per_trip DOUBLE DEFAULT NULL COMMENT '单车次载客人数',
  passengers_per_trip_city DOUBLE DEFAULT NULL COMMENT '单车次载客人数_城市内',
  passengers_per_trip_chengxiang DOUBLE DEFAULT NULL COMMENT '单车次载客人数_城际城乡',
  rate_op_vehicles_mom DOUBLE DEFAULT NULL COMMENT '运营车数环比增速',
  rate_op_vehicles_yoy DOUBLE DEFAULT NULL COMMENT '运营车数同比增速',
  rate_trip_mom DOUBLE DEFAULT NULL COMMENT '载客车次总数环比增速',
  rate_trip_yoy DOUBLE DEFAULT NULL COMMENT '载客车次同比增速',
  rate_passenger_mom DOUBLE DEFAULT NULL COMMENT '客运量环比增速',
  rate_passenger_yoy DOUBLE DEFAULT NULL COMMENT '客运量同比增速',
  avg_distance_mom_change DOUBLE DEFAULT NULL COMMENT '平均运距环比增减（公里）',
  avg_distance_city_mom_change DOUBLE DEFAULT NULL COMMENT '平均运距_城市内环比增减（公里）',
  rate_trip_city_mom DOUBLE DEFAULT NULL COMMENT '载客车次总数环比增速_城市内',
  rate_passenger_city_mom DOUBLE DEFAULT NULL COMMENT '客运量环比增速_城市内',
  rate_trip_chengxiang_mom DOUBLE DEFAULT NULL COMMENT '载客车次总数_城际城乡环比增速',
  rate_passenger_chengxiang_mom DOUBLE DEFAULT NULL COMMENT '客运量_城际城乡环比增速',
  avg_distance_chengxiang DOUBLE DEFAULT NULL COMMENT '平均运距_城际城乡（公里）',
  trip_city_ratio DOUBLE DEFAULT NULL COMMENT '载客车次总数_城市内占比',
  passenger_city_ratio DOUBLE DEFAULT NULL COMMENT '客运量_城市内占比',
  contact_person VARCHAR(100) DEFAULT NULL COMMENT '填表人',
  contact_phone VARCHAR(50) DEFAULT NULL COMMENT '联系电话',
  report_date VARCHAR(20) DEFAULT NULL COMMENT '报出日期',
  verify_explanation TEXT COMMENT '核实性原因解释',
  report_note TEXT COMMENT '上报说明',
  modify_record TEXT COMMENT '修改记录',
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (id),
  KEY idx_period (report_period),
  KEY idx_city (city)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='巡游出租汽车运营服务情况月报（市州级）';

CREATE TABLE IF NOT EXISTS city_taxi_auth (
  id BIGINT NOT NULL AUTO_INCREMENT,
  report_period VARCHAR(20) NOT NULL COMMENT '报表期 2026-07',
  city VARCHAR(50) DEFAULT NULL COMMENT '市州（由证号/档案号/地址提取）',
  plate_no VARCHAR(30) DEFAULT NULL COMMENT '车牌号码',
  vehicle_type VARCHAR(50) DEFAULT NULL COMMENT '车辆类型',
  biz_type VARCHAR(50) DEFAULT NULL COMMENT '经营类型',
  owner_name VARCHAR(100) DEFAULT NULL COMMENT '车主名称',
  license_no VARCHAR(100) DEFAULT NULL COMMENT '经营权号',
  archive_no VARCHAR(100) DEFAULT NULL COMMENT '档案号',
  road_cert_no VARCHAR(100) DEFAULT NULL COMMENT '道路运输证字号',
  fuel_type VARCHAR(50) DEFAULT NULL COMMENT '燃料类型',
  operator_name VARCHAR(200) DEFAULT NULL COMMENT '业户名称',
  operator_addr VARCHAR(300) DEFAULT NULL COMMENT '业户地址',
  op_status VARCHAR(20) DEFAULT NULL COMMENT '营运状态',
  cert_status VARCHAR(20) DEFAULT NULL COMMENT '证件状态',
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (id),
  KEY idx_period (report_period),
  KEY idx_city (city),
  KEY idx_period_city (report_period, city)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='出租车运政车辆信息（车辆级明细）';

-- åŸŽå¸‚客运第2步：巡游出租 7 ç»„审核规则（report_type=CITY_TAXI）
INSERT IGNORE INTO audit_rule (rule_name, rule_code, description, check_field, compare_type, threshold, alert_level, report_type, is_enabled, sort_order) VALUES
  ('运营车数与运政系统对比核实', 'RULE_T001', '月报运营车辆数与运政系统车辆数差距>3%需核实', 'opVehicles', 'CROSS_DIFF_PCT', '3', 'RED', 'CITY_TAXI', 1, 61),
  ('城市内与城际城乡客运量趋势一致核实', 'RULE_T002', '城市内客运量环比与城际城乡客运量环比趋势不一致且增速>2%需核实', 'passengerCityMom,passengerChengxiangMom', 'TREND_CONSISTENCY', '0.02', 'YELLOW', 'CITY_TAXI', 1, 62),
  ('客运量与旅客周转量趋势一致核实', 'RULE_T003', '客运量环比与旅客周转量环比（由平均运距推导）趋势不一致需核实', 'passengerMom,turnoverMomDerived', 'TREND_CONSISTENCY', '0.02', 'YELLOW', 'CITY_TAXI', 1, 63),
  ('城市内客运量占比变化核实', 'RULE_T004', '城市内客运量占比与上月相比变化>1%需核实', 'passengerCityRatio', 'RATIO_CHANGE', '0.01', 'YELLOW', 'CITY_TAXI', 1, 64),
  ('平均运距变化幅度核实', 'RULE_T005', '平均运距与上月相比变化超过3公里需核实（特别是城际城乡）', 'avgDistanceMomChange,avgDistanceCityMomChange,avgDistanceChengxiang', 'AVG_DIST_CHANGE', '3', 'YELLOW', 'CITY_TAXI', 1, 65),
  ('单车次载客人数系数变化核实', 'RULE_T006', '单车次载客人数=客运量/载客车次总数，与上月相比变化>0.2需核实', 'passengersPerTrip', 'PAX_PER_TRIP_CHANGE', '0.2', 'YELLOW', 'CITY_TAXI', 1, 66),
  ('载客车次总数与客运量趋势一致核实', 'RULE_T007', '载客车次总数环比/同比与客运量环比/同比趋势不一致需核实', 'tripMom,passengerMom,tripYoy,passengerYoy', 'TREND_CONSISTENCY', '0.01', 'YELLOW', 'CITY_TAXI', 1, 67);

 docs/¹«Â·ÂÿÍ/¹«Â·¿ÍÔ˼ò»¯.docx

Binary files differ

 docs/¹«Â·ÂÿÍ/¹«Â·ÂÿÍÖ¸µÄÊǹ«Â·°àÏß

 docs/¹«Â·ÂÿÍ/¹«Â·Âÿͼò»¯¹¤×÷.xlsx

Binary files differ

 docs/¹«Â·ÂÿÍ/¹«Â·°àÏß×¢Òâµã.png

 docs/¹«Â·ÂÿÍ/Ä£°å_½»ÆóͳH203-1±í_¹«Â·ÂÿÍÔËÊäÔ¶ÈÉú²úÇé¿ö.xlsx

Binary files differ

 docs/¹«Â·ÂÿÍ/Ä£°å_¹«Â·ÂÿÍÔËÕþ³µÁ¾Êý.xlsx

Binary files differ

 docs/¹«Â·ÂÿÍ/Éú³É_Öпھ¶·ÖÎö.xlsx

Binary files differ

 docs/¹«Â·ÂÿÍ/Éú³É_Öпھ¶ÅÅÃû.xlsx

Binary files differ

 docs/¹«Â·ÂÿÍ/Éú³É_Öпھ¶Ã÷ϸ.xlsx

Binary files differ

 docs/¹«Â·ÂÿÍ/Éú³É_¹«Â·ÂÿͷÖÊÐÖÝ.xlsx

Binary files differ

 docs/ͬÊ¿ª·¢¼Ç¼-20260827.md

New file
@@ -0,0 +1,778 @@
# HANDOFF.md â€” æ¯æ—¥äº¤æŽ¥æ–‡æ¡£

> **用法**：新对话开始后，先读本文件 + é¡¹ç›®æ ¹ç›®å½• `AGENTS.md`，即可无缝接力。
> **每天结束时**：把当天进展、踩过的坑、新需求、未完成事项更新到本文件，然后可以放心开新对话。

## ä¸€ã€å½“前状态（2026-08-27）
- **2026-08-27（用户环境修复：Chrome æ¸²æŸ“进程崩溃=迅雷扩展，与应用无关）**：用户反馈「登录后点数据导入浏览器崩溃」。排查结论：**非应用代码问题**——无头 Chrome å®Œæ•´æµç¨‹å¤šè½®ï¼ˆçœŸå®žç™»å½•â†’点击菜单→切 tab/下拉/刷新）+ Edge å‡ 0 å´©æºƒã€JS 0 é”™è¯¯ï¼›åŽç«¯ /import/batches æœ‰ limit ä¸Šé™æ— å¤§å“åº”。本机 Crashpad æœ‰ 3 ä¸ª**渲染进程**崩溃 dump（10:02/10:03/11:15），异常特征完全一致（code 0x517a7ed / addr 0xb57d5567=未初始化内存跳转），页面均为 localhost:8080，三次崩溃时唯一第三方扩展=「迅雷下载支持」（id ncennffkjdiamlpmcbajkmaiiiddgioo，document_start å…¨é¡µé¢æ³¨å…¥è‡ªå¸¦ Vue3 runtime + MutationObserver è§‚察整个 body DOM），Intel æ—§é©±åŠ¨ 27.20.100.9365 ä¸ºå åŠ å› ç´ ã€‚用户已在 Chrome ç§»é™¤è¯¥æ‰©å±•å¹¶æ”¹ç”¨ Edge，均不再崩溃。
  - **坑（务必记住）**：①正式版 Chrome å·²ç¦æ­¢å‘½ä»¤è¡ŒåŠ è½½æ‰©å±•ï¼ˆ--load-extension/--disable-extensions-except è¢«å¿½ç•¥ï¼Œæ—¥å¿—提示 not allowed in Google Chrome），headless æ— æ³•å¤çŽ°ã€Œå¸¦æ‰©å±•ã€åœºæ™¯ï¼›**Edge å…è®¸å‘½ä»¤è¡ŒåŠ è½½æ‰©å±•**（msedge.exe --load-extension=... + --user-data-dir=独立目录），可用于复现扩展相关问题。②用户 Chrome å´©æºƒè¯æ®çœ‹ %LOCALAPPDATA%\Google\Chrome\User Data\Crashpad\reports\*.dmp（minidump å¯æ‰‹å·¥è§£æžï¼šå¼‚常流 type=6、模块表 type=4，注释含 gpu-driver/extension-1/页面 URL）。③再遇「浏览器崩溃/白屏」先查 Crashpad æ˜¯å¦å«ç¬¬ä¸‰æ–¹æ‰©å±•ï¼Œå†æŸ¥æ‰©å±•/驱动，不要先怀疑应用。
  - äº§ç‰©ï¼š_shots/import_crash_repro*.js（headless å¤çŽ°ï¼‰ã€_shots/edge_repro.js（Edge+扩展复现）、_shots/xunlei_ext/（扩展副本）、_shots/cft/（Chrome for Testing ä¸‹è½½æ®‹ç•™ï¼‰ã€‚

- **2026-08-26（晚间续8，报表生成页 UI ä¼˜åŒ–为「Tab å·¥ä½œå°ã€+ å¤‡æ³¨å¼¹çª—，e2e å…¨ç»¿ï¼‰**：`ReportExport.vue`（23:27:55 Compiled）继续改版：
  - æŠ¥è¡¨ç±»åž‹æ”¹å›ž**顶部 5 ä¸ª Tab**（货运/旅客/城市客运/投资/能耗，城市客运带「公交/出租/轨道轮渡/汇总」标签），替代续7的下拉框方案。
  - æŸ¥è¯¢åŒºï¼šå‘¨æœŸå•é€‰ï¼ˆæœˆæŠ¥/年报，能耗只显示季报）+ æœˆä»½/年份**分组下拉**（能耗只列季度末月 3/6/9/12）+ æŸ¥è¯¢æŒ‰é’®ï¼›é€‰ 2026-07 åŽçŠ¶æ€åˆ·æ–°ã€‚
  - è´§è¿æ¨¡å—新增「源数据录入与校验」卡片：200 è¡Œæºæ•°æ®è¡¨æ ¼ï¼ˆä¼ä¸šåç§°/货运量/运输方式/统计月份），「校验数据」→ é”™è¯¯åˆ—表 + å‡ºé”™å•å…ƒæ ¼çº¢è‰²é«˜äº®ï¼ˆcell-error），「自动计算」→ æ±‡æ€»è¡Œï¼ˆæ€»è´§è¿é‡/平均货运量/各企业占比）；其余模块显示「暂未配置在线校验规则」提示。
  - æŠ¥è¡¨åˆ—表：勾选 + æŠ¥è¡¨å + çŠ¶æ€æ ‡ç­¾ï¼ˆæ•°æ®å°±ç»ª/未审核/缺数据）+ å¤‡æ³¨åˆ— + é¢„览/导出；底部全选/批量预览/批量导出保留。
  - **备注弹窗**（`openNoteDialog`/`saveNote`）：按报表 key æœ¬åœ°è®°å¿†ï¼ˆ`localStorage report_note_<key>`），保存后列表即时显示。
  - æ— å¤´ e2e `_shots/report_ui_opt_e2e.js`：5 Tab、周期/月份下拉、2026-07 ä¸‰å¼ æŠ¥è¡¨æ•°æ®å°±ç»ªã€æ ¡éªŒå¤±è´¥ 1 æ¡+红色高亮、自动计算汇总、投资 4 å¼ /能耗仅季报+季度末月、备注弹窗保存全部通过，JS 0 é”™è¯¯ï¼›æˆªå›¾ `_shots/report_ui_opt.png`。
  - **坑（已修复）**：备注弹窗 e2e æ›¾è¯¯æŠ¥ã€Œç©ºé¢„览弹窗标题」——`querySelector('.el-dialog__title')` å‘½ä¸­çš„是 DOM ä¸­ç¬¬ä¸€ä¸ªï¼ˆéšè—çš„）预览弹窗标题；改为取**可见** `.el-dialog__wrapper` å†…的标题/textarea/按钮后通过；另 localStorage æ–­è¨€é”®åº”为当前 Tab æŠ¥è¡¨ï¼ˆenergySummary è€Œéž cityDetail）。应用本身无缺陷（探针 `_shots/probe_note.js` ç¡®è®¤ç‚¹ç¼–辑图标即开「编辑备注」弹窗）。
  - é—ç•™/待办不变：见续5（货运 7 æœˆæ±‡æ€»è¡¨æœªå¯¼å…¥ã€æ—…客 1-6 æœˆ/2025 åŒæœŸç¼ºå¤±ã€8-12 æœˆä¾èµ–数据源、能耗新规则阈值待确认）。
- **2026-08-26（晚间续4再补，解释模块改「按需展开」）**：用户反馈左右布局仍不美观。设计判断：问题不在位置而在「常驻显示」——把解释编辑器一直摆在每条问题旁必然显挤。改为**浏览轻、编辑按需展开**（前端 17:41:58 Compiled）：明细视图卡片头是「解释：已填写/未填写」可点击标签，点开才在卡片内展开解释编辑区（收起按钮可关）；合并视图「企业解释」列默认只显示状态标签+2 è¡Œæ‘˜è¦+「填写/修改」按钮，点开才展开 textarea；两条视图内跳转「解释」链接已移除（原 goExplain é“¾æŽ¥æ”¹ç”±å±•å¼€é¢æ¿æ‰¿æ‹…，AI åˆ†æžä»åœ¨ä¼ä¸šè§£é‡Šé¡µï¼‰ã€‚默认页面回到干净状态。
- **2026-08-26（晚间续4补，解释模块改左右布局）**：用户反馈「解释放问题下面不好看，放右边」。已改（前端 17:38:55 Compiled）：明细视图卡片内 `card-body` æ”¹ flex ä¸¤æ â€”—左 `issue-detail`（规则+实际/基准/差异）、右 `explain-side`（固定宽 340 ç°åº•é¢æ¿ï¼šæ ‡ç­¾+已有解释+textarea+保存/重置）；合并视图把解释从问题明细单元格移出，**单独新增「企业解释」列（宽 360）**，位于「审核问题明细」与「操作」之间，非解释类报表（INVEST/H204）显示「—」。
- **2026-08-26（晚间续4，审核结果页内嵌企业解释）**：用户要求「审核问题明细后面直接加解释模块，不用跳转到另一个界面」。现状：审核结果页每条问题卡片只有跳转链接，且后端**原本没有保存解释的接口**（verifyExplanation åªè¯»ï¼‰ã€‚
  - åŽç«¯ `ExplainController` æ–°å¢ž `POST /api/explain/save`（reportType/reportId/explanation，H2032/H2031/CITY_BUS/CITY_TAXI å››ç±»ï¼ŒæŒ‰ reportId æ›´æ–°å¯¹åº”来源表 verifyExplanation，错误返回 Result.error）。
  - å‰ç«¯ `AuditResult.vue`（17:35:24 Compiled）：明细视图每条问题卡片底部、合并视图每家企业问题明细下方，内嵌「企业解释」模块——已有解释/未填写标签 + è‰ç¨¿ textarea + ä¿å­˜è§£é‡Š/重置；草稿按 reportId å…±äº«ï¼ˆåŒä¼ä¸šå¤šæ¡é—®é¢˜åŒ draft，保存后同步所有行）；加载结果统一走 `applyResults` åˆå§‹åŒ–草稿。企业解释页（ExplainReview）与审核结果页共用同一来源表，保存后两边一致；原「解释」跳转链接保留。
  - éªŒè¯ï¼š`POST /api/explain/save` ä¿å­˜â†’DB æ›´æ–°â†’explain/list å¯è§â†’已清测试数据；后端编译通过+重启就绪（PID 11732）。
- **2026-08-26（晚间续3，目录导入直连版 + æ–‡ä»¶åè‡ªåŠ¨è¯†åˆ«æœˆä»½ï¼‰**：用户反馈目录导入太慢/操作绕，且明确「文件夹里是多个月的数据，要按 Excel æ–‡ä»¶ååˆ†åˆ«å­˜åˆ°æ¯ä¸ªæœˆã€ã€‚
  - å‰ç«¯ `DataImport.vue`（17:21:59 Compiled）：去掉「选择文件夹」按钮，改为**目录路径输入框 + ã€Œå¯¼å…¥è¯¥ç›®å½•ã€**（回车也可触发）+「浏览…」辅助查找 +「跳过已导入文件」勾选（默认开，记住上次目录 localStorage `dirLast_<type>`）；逐文件导入显示实时进度（待导入/导入中/成功/失败/已跳过 + è¯†åˆ«åˆ°çš„月份标签）；目录导入不再强制要求先选报表期（报表期仅作无年份文件的后备年份）。
  - åŽç«¯ï¼ˆç¼–译通过+重启就绪，PID 10932）：`importDirFileByPath`/`importFromDir` å¢žåŠ  **`detectPeriod(fileName, period)` æŒ‰æ–‡ä»¶åè¯†åˆ«æŠ¥è¡¨æœŸ**（支持 `2026å¹´7月`/`2026å¹´07月`/`2026.7`/`2026-07`/`202607`/`7月`；无年份用 period å¹´ä»½æˆ–当前年份），识别不到且未选报表期则逐文件报错；新增**跳过已导入**（import_batch åŒ period+fileName ä¸” failRows=0 åˆ™è·³è¿‡ï¼Œ`skipImported` å‚数默认 true）；`fromDirFile`/`fromDir` çš„ period æ”¹ä¸ºå¯é€‰ã€‚识别规则注意：`202607` éœ€ 6 ä½è¿žæ•°å­—且年 2000-2100、月 1-12，避免误判。
  - éªŒè¯ï¼š`2026.6.xlsx→2026-06`、`202607.xlsx→2026-07`、`2026å¹´5月.xlsx→2026-05`、`7月.xlsx→2026-07`（当前年）、`未标注月份.xlsx→报错`；重跑 skipImported=true å…¨éƒ¨è·³è¿‡ï¼›æµ‹è¯•æ‰¹æ¬¡å·²æ¸…。
  - è¯­ä¹‰æé†’：同一类型同一报表期多个文件仍会「先清后写」互相覆盖（系统幂等规则），投资市州多文件请用专门的「市州单表批量导入」。
- **2026-08-26（晚间续2，文件夹导入改服务端目录浏览器 + åŒå‡»å³å¯¼å…¥ï¼‰**：用户反馈原生文件夹选择框「单击/双击会跳进下一级目录、看不到选择确认」。
  - æ ¹å› ä¸€ï¼šæµè§ˆå™¨åŽŸç”Ÿ `webkitdirectory` é€‰æ‹©æ¡†äº¤äº’（Chrome éœ€ç‚¹å³ä¸‹è§’「选择文件夹」确认，用户没看到）；根因二：`DataImport.vue` æ•´ä½“重写时丢了 `endpoint()` æ–¹æ³•ï¼ˆ`importOne` è°ƒ `this.endpoint(row.type)` å¿…抛 TypeError，**所有文件导入其实都是坏的**）——本次已补回完整 type→URL æ˜ å°„。
  - æ–¹æ¡ˆï¼šå¼ƒç”¨æµè§ˆå™¨åŽŸç”Ÿæ–‡ä»¶å¤¹é€‰æ‹©æ¡†ï¼Œæ”¹ä¸º**服务端目录浏览器**（前后端同机，数据在 `docs/`）：后端新增 `GET /api/import/dirs?path=`（path ç©º=项目 docs，含子目录列表+当前目录 Excel æ–‡ä»¶å/数量；docs å®šä½å‘上查找 4 å±‚，兼容 IDEA ä»¥ server æ¨¡å—目录启动）与 `POST /api/import/fromDir`（type/period/dir，扫描直接包含的 .xlsx/.xls，`ByteArrayMultipartFile` åŒ…装后复用各类型既有解析方法，逐文件返回成功/失败/错误）。
  - å‰ç«¯ `DataImport.vue`：「选择文件夹」打开应用内对话框（当前路径/上级目录/数据目录 docs/子目录列表/当前目录 Excel é¢„览），**单击=进入子文件夹，双击目标文件夹=立即导入**；也可进入后点「选择此文件夹并导入」；导入结果逐文件弹窗展示；队列单文件导入流程保留。
  - éªŒè¯ï¼šåŽç«¯ç¼–译通过+重启就绪（start-dev.ps1，PID 32576）；`/api/import/dirs` è¿”回 docs å„模块目录与 15 ä¸ªåŸŽå¸‚客运 Excel；`/api/import/fromDir` å®žæµ‹æ¨¡æ¿_轨迹里程.xlsx→628 è¡Œï¼ˆçœŸå®žè§£æžæˆåŠŸï¼‰ï¼›æµ‹è¯•äº§ç”Ÿçš„ track_mileage 2026-03 æ•°æ®å·²ç”¨ç©ºæ–‡ä»¶é‡å¯¼æ¸…零、import_batch æµ‹è¯•è®°å½•(34/35/36)已删；前端 17:03:58 Compiled successfully。
  - å¾…办：请用户刷新页面手测「选择文件夹→双击目标文件夹即导入」；临时测试目录 `%TEMP%\dirimport_test`、`%TEMP%\dirimport_empty` ä¿ç•™æœªåˆ ã€‚
- **2026-08-26（晚间，报表标题全动态化）**：按用户要求「标题不要写死，根据审计员选择的月份/年份显示」完成收尾（承前：城市客运 6 è¡¨ã€Œå¯¼å…¥æ¨¡æ¿_*.xlsx」已由既有「生成_*.xlsx」复制补齐，此前引用文件不存在导致 500）：
  - â‘  `dynamicTitle` ä»Žã€Œå‰ 6 è¡Œã€æ”¹ä¸ºå…¨è¡¨æ‰«æï¼šè¡¥ä¸Šåˆ†å¸‚州第 2 å—标题（r23「城市客运客运周转量分市州1-N月累计情况」）；「1-12月」整年对比块（2024/2025）标题保持原样，不再被误改成选中年。
  - â‘¡ æ–°å¢ž `cumRange(month)`：1 æœˆæ˜¾ç¤ºã€Œ1月」不再出现「1-1月」，应用于货运量/周转量排名累计块、中口径分析、投资预安排表头、城市客运标题。
  - â‘¢ æ–°å¢ž `fixPassengerHeaderYear`：公路旅客分市州/中口径明细表头年份动态化（此前选 2027 ä»æ˜¾ç¤ºã€Œ2026å¹´1月/2026年累计」）。
  - â‘£ è½¨é“轮渡明细补调 `dynamicTitle`（此前表头年份写死 2026）。
  - éªŒè¯ï¼š2026-01/2026-07/2026-12（年报）/2027-01 Ã— å…¨æ¨¡å— 17 å¼ å¯¼å‡ºæ ‡é¢˜å…¨éƒ¨æ–­è¨€é€šè¿‡ï¼ˆæ ·ä¾‹è§ `%TEMP%\title_check\*FINAL*`）；汇总表 G1/M1/G12 å¯¹æ¯”块标题正确保留 2025/2024。
  - é—留（属模板结构，未改）：投资亿元表 3 çš„季度固定列（1-3月实际/4月计划/Q2/1-4月累计/5月/6月等）为模板固定列，年份已动态、月份固定是模板设计；投资十五五模板 sheet0「年    æœˆã€å ä½ä¸Žå®˜æ–¹æ ·ä¾‹ä¸€è‡´ã€‚
- **2026-08-26（晚间续，报表数据预览轻量版）**：导出前先看数据有没有缺/不对。后端新增 `GET /api/report/preview`（period/mode/types，复用 checkExportReady çš„就绪/审核状态，逐模块算月度覆盖 + æ ¸å¿ƒæŒ‡æ ‡æ‘˜è¦ + é—®é¢˜æ¸…单）：货运=模板湖北省行 1..N æœˆåˆ—覆盖 + å…¨çœç´¯è®¡è´§è¿é‡/周转量（合计/规上/规下）；旅客=源表逐月覆盖 + ä¼ä¸š/个体累计；城市客运=公交/出租/轨道/轮渡累计（汇总 3 è¡¨è¦†ç›–=公交∪出租，公交明细/轨道轮渡只看公交表）；投资=当月报表只提示当月缺失 + é¡¹ç›®æ•°/本月完成/自年初/自开始累计；能耗=季度数据 + è½¦è¾†æ•°/燃油消耗。前端 `ReportExport.vue` æ¯æ¨¡å—加「预览数据」按钮 + å¼¹çª—（状态标签 å°±ç»ª/缺数据/未审核、月度覆盖、摘要表、问题清单）。验证：2026-07 å…¨æ¨¡å— 18 å¼ ã€2026-08（未审核+缺数据）、2026-12 å¹´æŠ¥ã€2027-01 å…¨éƒ¨æ­£ç¡®ï¼›å‰ç«¯ Compiled successfully。
  - é¢„览顺带暴露的数据现状（供用户核对）：货运模板仅 2026-07 ä¸€æœŸä¸” 7 æœˆåˆ—为空（累计只有 1-6 æœˆ 9.7 ä¸‡å¨ï¼Œè§„上 3754 ä¸‡å¨ â†’ è§„下为负，口径存疑）；旅客/出租仅 7 æœˆã€æŠ•èµ„ä»… 6-7 æœˆå¯¼å…¥ï¼›å…¬äº¤æœˆæŠ¥æœªå¯¼å…¥ï¼ˆè½¨é“/轮渡 0 æ•°æ®ï¼‰ã€‚
- **2026-08-26（午后，报表生成 P0 ä¸‰é¡¹ + æ¨¡æ¿è§„则梳理）**：①导出前数据就绪校验——后端 `GET /api/report/ready`（按报表类型检查依赖表行数：货运=模板_货运量周转量+规上规下拆分表+H203-2、旅客=H203-1+个体、公交/出租、投资=investment_monthly、能耗=h204_vehicle_quarterly），前端导出前弹「数据未就绪」确认框（列出具体缺哪张表，可继续导出空表）；②错误透出——新增 `GlobalExceptionHandler`（HTTP 500 + Result{code,message}），前端 `failWith` æ˜¾ç¤ºåŽç«¯å…·ä½“原因；③文件名统一——前端 4 ä¸ªæ—…客 fileName å¯¹é½åŽç«¯ï¼ˆç”Ÿæˆ_公路旅客分市州明细/中口径明细/中口径排名/中口径分析.xlsx），`buildResponse` æŒ‰ .xls/.xlsx è®¾ç½® MIME；④顺手修 `ReportExport.vue` ç¼º `activeMenu` å®šä¹‰ï¼ˆä¾§è¾¹æ é«˜äº®å¤±æ•ˆï¼‰ã€‚验证：ready æŽ¥å£æ•°å€¼ä¸Ž DB é€è¡¨æ ¸å¯¹ä¸€è‡´ï¼ˆcityDetail=690=ft18+scale36+h2032=636、旅客 771、出租 17、投资 179、能耗 126、公交 0 å› å…¬äº¤æœˆæŠ¥æœªå¯¼å…¥ï¼‰ï¼›æ— å¤´æµè§ˆå™¨ä¸¤åœºæ™¯ PASS（缺数据弹确认框、数据齐全直接下载）；前端 12:55:10 Compiled。截图 `_shots/report_ready_dialog.png`。
### 2026-08-26 æ™šé—´ä¼šè¯ï¼šæŠ¥è¡¨ç”Ÿæˆä¸‰å£å¾„落地（公式保留/动态插行/审核前置+1~N累计，已完成验证）
**背景**：用户确认三项口径——①所有模板保留公式、只填原始量、公式部分自动算；②动态插行并同步公式范围；③先审核再出表、1~N月累计=一月到N月求和。
**①公式保留（现状核对，无需改）**
- èƒ½è€—/城市客运/旅客 8 å¼ å¯¼å‡ºå·²æ˜¯ã€Œæ¨¡æ¿åº•ç¨¿ + å…¬å¼å•å…ƒæ ¼ä¿ç•™ + evaluateAll é‡ç®—」：旅客分市州/中口径排名/分析、能耗汇总、城市客运 3 å¼ åˆè®¡/同比/占比公式均在导出后重算；投资 4 è¡¨ä¸Žè´§è¿æ¨¡æ¿æœ¬èº« 0 å…¬å¼ï¼ˆåˆè®¡/同比由系统算好写入）。旅客模板历史 `#REF!` å¼•ç”¨ä¸å½±å“å¡«å……。
- é¡ºæ‰‹ä¿®å¤ï¼ˆä¸Šä¸‹åˆä¼šè¯ï¼‰ï¼š`application.yml` çš„ `passenger.template-dir` åŽŸæŒ‡å‘不存在的 `docs/公路旅客/输出` å¯¼è‡´æ—…客导出 500，已改为 `docs/公路旅客`；`REPORT_FILE_NAMES` æ—…客 zip å†…文件名改全名。旅客 4 è¡¨å¯¼å‡ºå·²æ¢å¤ HTTP 200（size≈13.6KB）。
**②动态插行（本次新增，投资 3 è¡¨ï¼‰**
- æ”¹åŠ¨é›†ä¸­åœ¨ `ReportExportService.java`（`investPlan`/`investFiveYearLogistics`/`investCounty`）：结构扫描（块→市州小节→项目行）→ åŽŸä½å¡«å……模板行（记录已匹配项目 id）→ è‡ªåº•å‘上按小节插行补齐 DB å¤šä½™é¡¹ç›® â†’ æŒ‰å—/市州重排序号。`insertRowsDown`（shiftRows + åˆå¹¶åŒºå…ˆæ‘˜é™¤å†æŒ‰æ–°è¡Œå·æ¢å¤ + `createRowLike` å¤åˆ¶æ ·å¼/行高/单行合并）、`renumberInvestSeq`（表1按块重置、表2按市州重置、表4全表连续）、`InvestSection` ç­‰è¾…助方法一并加入。表3（亿元投资）原本就是动态生成，未动。
- éªŒè¯ï¼ˆ2026-07）：模板 è¡¨1 å®¢è¿ 45 è¡Œ/物流 121 è¡Œï¼ŒDB 46/132 â†’ è¾“出 179 è¡Œï¼ˆ46+133，其中 1 æ¡ä¸ºæ—¢æœ‰æ¨¡ç³ŠåŒ¹é…é‡å¤ã€Œè†å·žå¸‚瑞海国际物流园」，非本次引入）；十堰 ç‰©æµå°èŠ‚模板 7 è¡Œâ†’DB 38 ä¸ªâ†’插 31 è¡Œï¼ˆDB å¡«æŠ¥å•ä½ä¸ºåå °çš„ 38 ä¸ªé¡¹ç›®å…¨éƒ¨ä¸Šè¡¨ï¼Œå«åç§°å¸¦æ­¦æ±‰/黄石的跨市项目，属数据现状）。表2 åäº”五 35 è¡Œ=DB 35 ä¸ªï¼ˆæ¨¡æ¿ 63 è¡Œæ— æ’行）；表4 ç»æµŽå¼ºåŽ¿ 38 è¡Œï¼ˆ36 ä¸ª DB + 2 æ¡æ—¢æœ‰é‡å¤åŒ¹é…ï¼šæžæ±Ÿ/应城）。合计/块/市州小节数值与 DB èšåˆä¸€è‡´ï¼ˆå…¨çœ 11429050.52、十堰物流 5111586）；合并区 111 ä¸ªã€0 é‡å ã€éšæ’行正确下移；序号连续（客运 1-46、物流 1-133）。
- è¯´æ˜Žï¼šæŠ•èµ„模板无公式，「公式范围同步」无需处理；旅客/城市客运/能耗模板数据区固定（17/18 å¸‚州行）不会超行，若未来需要插行，shiftRows ä¼šè‡ªåŠ¨åŒæ­¥å…¬å¼å¼•ç”¨ã€‚
**③先审核再出表 + 1~N ç´¯è®¡ï¼ˆå·²å°±ç»ªï¼‰**
- `checkExportReady` å·²æ–°å¢ž `auditRows`/`audited` å­—段（按 `audit_rule.report_type` â†’ `audit_result.report_period` ç»Ÿè®¡ï¼‰ï¼Œå‰ç«¯å¯¼å‡ºå‰å¼¹çª—区分「【缺数据】/【未审核】」。验证：跑 CITY_TAXI å®¡æ ¸ï¼ˆ`POST /api/audit/execute?period=2026-07&reportType=CITY_TAXI`，4 æ¡ï¼‰åŽ ready æŽ¥å£ `cityTaxiDetail auditRows=4 audited=true`，不再提示未审核。
- 1~N æœˆç´¯è®¡è¯­ä¹‰ç¡®è®¤ï¼š`freightCum`/`midCumClass`/`passengerCumSum` å‡ä¸º 1..N æœˆæ±‚和（如 2026-07 æœˆæŠ¥ç´¯è®¡=1-7月之和；旅客分市州模板月度列固定 1-6 æœˆï¼Œæ•… fillMonths=min(currentMonth,6)，超出部分以模板列数为准）。
**待确认/遗留**
- å…¶ä½™ç±»åž‹å®¡æ ¸å°šæœªé‡è·‘（全库清空后仅 H2032=1002 æ¡ + æœ¬æ¬¡ CITY_TAXI=4 æ¡ï¼‰ï¼šå¦‚需 ready ä¸å†æç¤ºæœªå®¡æ ¸ï¼Œè¯·åœ¨é¡µé¢æ‰§è¡Œ H2031/INVEST/H204 å®¡æ ¸ï¼ˆæˆ–让 AI ä»£è·‘）。
- æŠ•èµ„模糊匹配存在重复（同模板行匹配到同一 DB é¡¹ç›®ï¼‰ï¼Œå¦‚需可用「已用项目集合」约束匹配（会改变现有输出，需确认）。
- è¡¨1 åå °ç‰©æµ 38 ä¸ª DB é¡¹ç›®å«å¤§é‡åç§°å¸¦æ­¦æ±‰/黄石的项目（填报单位=十堰），若数据口径有误需在导入源头核对。
- é—留不变：7-12 æœˆæ¨¡æ¿å¾…用户提供；能耗新 6 æ¡è§„则阈值口径待确认；代码仍未提交 Git。

- **2026-08-26（中午，M2 å®Œæˆï¼‰**：投资市州单表批量导入落地并全量验证（`/api/import/investCityBatch`，参数 period/category=客运站场|物流园区，扫描 `docs/投资/输入/{客运（客运站）|物流（物流园区）}/{N月}`，跳过 pdf）：客运 6月35/7月46、物流 6月132/7月133 æ¡ï¼Œ0 å¤±è´¥ï¼›`total_investment` ä¿®å¤ç”Ÿæ•ˆï¼ˆèˆªå‘智慧物流园=69876，导出合计 2038714.59 ä¸Ž DB èšåˆä¸€è‡´ï¼‰ï¼›ä¿®å¤ã€Œæ€»æŠ•èµ„ vs è®¡åˆ’总投资（表头带空格）」+「公式单元格读缓存值（.et è·¨è¡¨å…¬å¼ï¼‰ã€+「多 sheet åŽ†å²æ–‡ä»¶æŒ‰æŠ¥è¡¨æœŸé€‰ sheet（襄阳 .et æ­¤å‰é”™é€‰ 2月 sheet）」。十五五模板 63 é¡¹è§„范化匹配 35 è¦†ç›–，28 ä¸ªçœŸå®žç¼ºå£æ¸…单在 `_shots/five_year_report.txt`（数据源不在市州单表，需用户提供）。
- **2026-08-26（凌晨）**：用户 4 é¡¹æ„è§å…¨éƒ¨å¤„理完毕（详见末尾「2026-08-26 å‡Œæ™¨ä¼šè¯ã€ï¼‰ï¼šâ‘ æ¨¡æ¿ä¸€è‡´æ€§â€”—修正 `application.yml` æ¨¡æ¿è·¯å¾„（passenger→`docs/公路旅客/输出`，新增 `energy.template-dir: docs/能耗`），能耗模板文件名改为用户最新更新的 `生成_能运汇总表.xlsx`，货运/旅客/能耗/城市客运 10 å¼ å¯¼å‡ºç»“æž„+合并+列宽全部与模板 PASS；②审核规则——H204 èƒ½è€—è¡¥ 6 æ¡è§„则（RULE_E005~E010，共 10 æ¡ï¼Œéœ€æ±‚ 7 æ¡å…¨è¦†ç›–），实现规则管理页（后端 `RuleManageController` + `RuleManage.vue`，按报表类型查看 6 ç±»å…¨éƒ¨è§„则、可启停/改阈值），CITY_TAXI 7 æ¡ç¡®è®¤å¼•æ“Žä¸Žå…¥åº“完整；③企业解释行高压缩（ExplainReview.vue ç´§å‡‘行高 + è§£é‡Šåˆ—限高滚动）；④重复导入确认后端全部幂等（同报表期先删后插）+ å‰ç«¯ loading é˜²è¿žç‚¹ï¼Œä¸ä¼šå­˜ä¸¤ä»½ã€‚
- **注意**：数据库已于 2026-08-26 00:45 æŒ‰ç”¨æˆ·è¦æ±‚全库清空（26 å¼ è¡¨ TRUNCATE，备份 `_shots/db_backup_20260826_004520.sql` 28MB），`audit_rule` å·²æ¢å¤ 33 æ—§æ¡ + æ–°å¢ž 6 æ¡=39 æ¡ï¼ˆH2032=6/H2031=8/H204=10/INVEST=4/CITY_BUS=4/CITY_TAXI=7），`sys_role` ç­‰é…ç½®è¡¨ä»ä¸ºç©ºéœ€é‡æ–°åˆå§‹åŒ–；业务数据需重新导入。
- **2026-08-25（晚上续）**：按用户确认口径完成：报表生成页重排（货运→公路旅客→城市客运在旅客右边→能耗→投资）、生成内容改「多选下拉+导出」单按钮、货运/旅客/城市客运/投资全部支持月报/年报（能耗保持季度末月）、能耗汇总表改为模板底稿生成（模板_能运汇总表 .xlsx）、投资 4 è¡¨åˆ—宽与样例对齐（样例无合并/无自定义列宽）、企业解释支持“未填写”+“仅显示已填写”开关、数据导入页美化（状态列/类型说明/默认期）。详见末尾交接记录。
- **2026-08-25（晚上续）**：按用户确认口径完成：报表生成页重排（货运→公路旅客→城市客运在旅客右边→能耗→投资）、生成内容改「多选下拉+导出」单按钮、货运/旅客/城市客运/投资全部支持月报/年报（能耗保持季度末月）、能耗汇总表改为模板底稿生成（模板_能运汇总表 .xlsx）、投资 4 è¡¨åˆ—宽与样例对齐（样例无合并/无自定义列宽）、企业解释支持“未填写”+“仅显示已填写”开关、数据导入页美化（状态列/类型说明/默认期）。详见末尾交接记录。
- **2026-08-25（下午）**：报表生成/企业解释/数据导入三页 UI é‡æž„（详见末尾交接记录）：城市客运三模块合并为一张卡、五模块统一「勾选+一键全部zip」、报表期支持月报/年报、企业解释扩展 H2031/CITY_BUS/CITY_TAXI、数据导入分组+最近批次、报表生成留痕（sys_operation_log）。
- **2026-08-25（最新）**：数据库连接根因修复（JDBC URL ç¼º `allowPublicKeyRetrieval=true，MySQL8 caching_sha2_password å¯¼è‡´æ‰€æœ‰ DB æŸ¥è¯¢ 500），已加回并重启验证；城市客运公交/出租 2026-07 å®¡æ ¸ç»“果重跑恢复（53/6 æ¡ï¼Œä¸Ž 08-24 ä¸€è‡´ï¼‰ï¼›6 å¼ æŠ¥è¡¨é‡æ–°ç”Ÿæˆæ•°å€¼å…¨éƒ¨æ ¸å¯¹é€šè¿‡ï¼›æ±‡æ€»è¡¨ç½‘约车行修复为显式 0（详见末尾交接记录）。
- **2026-08-24（最新）**：城市客运公交/巡游出租报表改为**按目录下模板底稿生成**（`城市公交_模板.xlsx`/`巡游出租_模板.xlsx`），保留模板标题/表头/合并单元格/公式/样式，仅填数据区；全省 7 æœˆå››æŒ‡æ ‡ä¸Žæ¨¡æ¿ 0 å·®å¼‚。
- **2026-08-24（最新）**：城市客运第 2 æ­¥ï¼ˆå·¡æ¸¸å‡ºç§Ÿï¼‰å·²è½åœ°ï¼šå·¡æ¸¸å‡ºç§ŸæœˆæŠ¥å¯¼å…¥ï¼ˆ`/api/import/cityTaxi`，市州级 17 è¡Œï¼‰ã€å‡ºç§Ÿè½¦è¿æ”¿è½¦è¾†å¯¼å…¥ï¼ˆ`/api/import/cityTaxiAuth`，42636 è¡Œï¼Œå¸‚州由证号/档案号/经营权/地址正则提取）、7 ç»„审核规则（RULE_T001~T007，report_type=CITY_TAXI，7 æœˆå®¡æ ¸ 6 æ¡ï¼‰ã€åˆ†å¸‚州报表（`/api/report/export/cityTaxiDetail`，全省+17 å¸‚州×4 æŒ‡æ ‡ï¼Œä¸Ž `巡游出租_模板.xlsx` 7 æœˆæ•°å€¼ 0 å·®å¼‚：5860.24/34236.60/5351.24/27422.13）。第 1 æ­¥å…¬äº¤ï¼ˆCITY_BUS）保持正常（53 æ¡ï¼‰ã€‚
- å‰åŽç«¯å‡åœ¨è·‘：后端 8090（start-dev.ps1 å¯åŠ¨ï¼Œæ—¥å¿— backend.log）、前端 8080（vue-cli serve，热更新已加载公交+巡游出租入口）。
- **2026-08-24（最新）**：城市客运报表系列（6 è¡¨ + zip）按目录模板生成落地：公交/出租/轨道轮渡明细、分市州累计、各市州明细表、汇总，见 `docs/城市客运/输出/`；轨道/轮渡数据从公交源文件扩展入库（详见续5）。
- åŸŽå¸‚客运第 3 æ­¥ï¼ˆç½‘约车拆分）待部级数据源；投资 M2（市州单表解析）已完成（见上方条目）。
- æŠ•èµ„ M2（市州单表批量导入）已完成并验证（详见末尾「2026-08-26 ä¸­åˆä¼šè¯ï¼šM2 å¸‚州单表批量导入」）；28 ä¸ªåäº”五项目缺口数据源待用户提供。
## äºŒã€å¿«é€Ÿå¯åŠ¨
统一用一键脚本（必须沙箱外/提权运行）：
```
powershell -NoProfile -ExecutionPolicy Bypass -File start-dev.ps1
```
- è„šæœ¬ä¼šè‡ªåŠ¨æ£€æµ‹ 8090/8080 æ˜¯å¦å·²ç›‘听并跳过重复启动，等待就绪后打印结果。
- æˆåŠŸæ ‡å¿—：`backend.log` å‡ºçŽ° `Started TrafficAuditApplication`；`frontend.log` å‡ºçŽ° `Compiled successfully` + `App running at:`。
- è®¿é—®åœ°å€ï¼šå‰ç«¯ `http://localhost:8080`（`/api` ä»£ç†åˆ°åŽç«¯ 8090）。
- å¯åŠ¨çš„三个历史坑及对策：见 `AGENTS.md`（Path/PATH é‡å¤â†’不用 Start-Process；node æ²™ç®± EPERM→必须提权；不嵌套 powershell -Command）。

## ä¸‰ã€é¡¹ç›®æ¦‚览
- ç³»ç»Ÿï¼šäº¤é€šè´§è¿ç»Ÿè®¡å®¡æ ¸ç³»ç»Ÿï¼ˆæ¹–北），先做"交企统H203-2表_道路货物运输月度生产情况"演示。
- å‰ç«¯ï¼šVue 2 + Element UI，`traffic-audit-web`，端口 8080。
- åŽç«¯ï¼šSpring Boot 2.x + MyBatis Plus + EasyExcel，`traffic-audit-server`，端口 8090。
- æ•°æ®åº“：MySQL（本机 3305 ç«¯å£ï¼Œåº“名 `traffic_audit`；账号密码见 `traffic-audit-server/src/main/resources/application.yml`）。
- LLM：DeepSeek API（`deepseek-chat`，配置同样在 application.yml；注意不要把 API Key å†™è¿›ä»»ä½•æ–‡æ¡£ï¼‰ã€‚
- æ ¸å¿ƒæ¨¡å—：数据导入（5类）、审核引擎（规则驱动）、AI åˆ†æžï¼ˆè„±æ•+查库+解释生成）、报表生成（3类）、用户权限（三员分离）。

## å››ã€å·²å®ŒæˆåŠŸèƒ½ï¼ˆæˆªè‡³ 08-07）
- æ•°æ®å¯¼å…¥ï¼šH203-2月报、运政车辆、轨迹里程、规上规下拆分、货运量周转量；导入失败显示行号。
- å®¡æ ¸ï¼šè§„则表驱动（整车吨位范围 4≤且≤40、货运类型环比中文+数量等），结果支持按企业名称/规则过滤。
- AI åˆ†æžï¼ˆ`AiChatDialog.vue`）：结构化 Markdown æŽ’版、逐字打字动画（约70字符/秒）、打字时同步平滑滚动、思考中蹦跳小人（发送后也显示）、语音输入+语音播报、对话可查数据库、弹窗固定屏幕居中圆角。
- ä¼ä¸šè§£é‡Šï¼šç‹¬ç«‹èœå•ï¼ˆExplainReview），与审核结果分离；AI é€æ¡åˆ†æžã€‚
- æŠ¥è¡¨ç”Ÿæˆï¼šè´§è¿é‡åˆ†å¸‚州明细、货运量排名、周转量排名。
- å¸ƒå±€ï¼šé¡¶éƒ¨æ ‡é¢˜+左侧菜单固定，内容区表格内部滚动；悬浮提示框已限宽（App.vue å…¨å±€ `.el-tooltip__popper` max-width）。
- æ–‡æ¡£ï¼š`AGENTS.md`、`start-dev.ps1`、`docs/Codex功能清单.md`、`docs/每日反思任务.md`、`docs/architecture.md`、`docs/database.md`、`docs/init.sql`。

## äº”、用户偏好 / ä¸šåŠ¡è§„则（务必遵守）
1. å…¨ç¨‹ä¸­æ–‡äº¤æµï¼›ä¸´æ—¶è„šæœ¬/文件未经同意不删。
2. æŠ¥è¡¨æœŸ**以页面选择为准**（选几月就是几月，忽略 Excel é‡Œçš„月份文字）；累计=1~N æœˆï¼ŒN=所选月。
3. è§„上规下拆分表"全省"行：**忠实导入，不要自己求和**（周转量、同比都一样，是什么就存什么）。
4. æ•°å€¼å¤„理：**不用 BigDecimal**，小数用 double è¯»å…¥/运算/存储；整数存整数；可接受尾差。
5. è´§è¿é‡å‘¨è½¬é‡è¡¨æ˜¯**输入**（每月导入），不是输出；货运量=规上+规下合计；规上货运量从 H203-2 æŒ‰ 17 å¸‚州合计（市州关系见 `docs/各市州所属组织机构.xlsx`），规下=合计−规上。
6. AI äº¤äº’数据**先脱敏再发送**（需求见 `requirement/货运简化.docx` ç¬¬78行；设计见 `docs/database.md` ç¬¬ä¸ƒç«  `llm_desensitize_map`）。
7. AI åˆ†æžè¾“出要"一眼看到结构和重点"：标题加粗、结论/建议/依据等标签块。
8. å®¡æ ¸ç»“果与"企业解释 AI åˆ†æž"是两个独立功能，不要混在一起。

## å…­ã€æ–‡æ¡£ç´¢å¼•
- éœ€æ±‚：`requirement/货运简化.docx`（+ `docs/` å‰¯æœ¬ï¼‰ã€`docs/01-交通运输部门统计调查制度.docx`、`docs/02-交通运输企业统计调查制度.docx`。
- æ¨¡æ¿/生成表：`docs/模板_*.xlsx`、`docs/生成_*.xlsx`。
- è®¾è®¡ï¼š`docs/architecture.md`、`docs/database.md`、`docs/init.sql`。
- è¿ç»´ï¼š`AGENTS.md`、`start-dev.ps1`、`docs/每日反思任务.md`（每日反思自动化待启用）。

## ä¸ƒã€å¾…办 / å·²çŸ¥äº‹é¡¹
- æ¯æ—¥åæ€è‡ªåŠ¨åŒ–尚未创建（提示词已备好，见 `docs/每日反思任务.md`；需要 automation å·¥å…·å¯ç”¨çš„会话）。
- å®˜æ–¹ Codex æ‰‹å†Œæœ¬æœºè®¿é—® 403，`docs/Codex功能清单.md` å¾…网络恢复后补官方核实版。
- åŽç»­æ‰©å±•ï¼šH203-1 å…¬è·¯æ—…客、W203 æ°´è·¯ã€P203 æ¸¯å£ã€H204 èƒ½æºç­‰ï¼ˆéœ€æ±‚文档 v2/v3 è®¡åˆ’），先把 H203-2 æ¼”示做好。

## å…«ã€æ¯æ—¥äº¤æŽ¥çº¦å®š
1. æ–°å¯¹è¯ç¬¬ä¸€æ­¥ï¼šè¯» `AGENTS.md` + `HANDOFF.md`；涉及 AI åˆ†æž/审核时参考 `docs/` ä¸Žæ•°æ®åº“表结构。
2. æ¯å¤©ç»“束时：更新 `HANDOFF.md`（进展、坑、新需求、待办），再关对话。
3. è·¨é¡¹ç›®å¯å¤ç”¨ç»éªŒæ²‰æ·€åˆ°æœºå™¨çº§é¡¶å±‚ AGENTS.md（本项目不再重复）。
## ä¹ã€Git ä»“库（2026-08-14 å»ºç«‹ï¼‰
- è¿œç¨‹ï¼šGitee **私有**仓库 https://gitee.com/jichengxiong/trafficAudit ï¼Œåˆ†æ”¯ `main`（提交身份 xyc <jc_xiong@hotmail.com>）。
- æ•æ„Ÿé…ç½®ä¸å…¥åº“：`traffic-audit-server/src/main/resources/application.yml` å·²åœ¨ `.gitignore` ä¸­ï¼Œ
  ä»“库内只提交占位符模板 `application.yml.example`（`${DEEPSEEK_API_KEY}` ç­‰ï¼‰ã€‚新环境：复制模板为 application.yml å¹¶å¡«çœŸå®žå€¼ã€‚
- æ—¥å¸¸æµç¨‹ï¼š`git add -A` â†’ `git commit -m "..."` â†’ `git push`（HTTPS push éœ€è¦ Gitee ç§äººä»¤ç‰Œæˆ–已保存凭据）。
- æ³¨æ„ï¼š`backend.log`、`frontend.log`、`node_modules/`、`dist/`、`target/` ç­‰ä¸å…¥åº“。

## åã€äº¤æŽ¥è®°å½•ï¼š2026-08-22 ~ 08-23（扩展模块调研）

### èƒŒæ™¯
用户提出在货运（H203-2）基础上扩展新功能，业务范围含：公路旅客运输、能耗、城市客运、投资。

### å·²åš
1. **通读项目**：AGENTS.md / HANDOFF.md / docs éœ€æ±‚与设计 / requirement/货运简化.docx，掌握现状（代码仅货运一条链路）。
2. **模板实拆**（docs/扩展表模板/ ç”¨æˆ·æ–°æ”¾ï¼‰ï¼š
   - å…¬è·¯æ—…客 H203-1：企业月报明细（28 åˆ—）+ è¿æ”¿å¯¹æ¯” + åˆ†å¸‚州生成表；审核 4 ç»„规则
   - èƒ½è€— H204（季报）：车辆粒度明细（18 åˆ—）+ è¿æ”¿ä¿¡æ¯ + æ±‡æ€»è¡¨ï¼›å®¡æ ¸ 7 ç»„规则（2 ç»„需跨表引用货运月报）
   - åŸŽå¸‚客运：市州级生成表 + ç½‘约车部级下发拆分；公交 4 ç»„ + å‡ºç§Ÿ 7 ç»„规则
   - æŠ•èµ„：输入=17 å¸‚å·ž 6/7 æœˆå®¢è¿ç«™åœº+物流园区月报（**格式不统一**，xls/xlsx/et/pdf æ··å­˜ï¼Œ20~26 åˆ—）；输出=4 å¼ å›ºå®šæ ¼å¼é¢†å¯¼è¡¨ï¼›å¦æœ‰æŠ•èµ„系统查询导出可对接
3. **产出文档**：
   - docs/扩展模块评估.md：模块×复用度评估、实施顺序（H203-1→H204→城市客运→投资）、架构建议（报表类型注册表化、审核引擎新增比较类型）、工作量粗估
   - docs/开源项目对比.md：GitHub æ£€ç´¢ç»“论（无直接同类）、四类参照项目（NIC MSR / RuoYi / JimuReport+DataEase / Griffin+GX+Soda）对比与启示
4. **临时文件**：根目录 .tmp_*.py（解析脚本）+ .tmp_货运简化.txt，未删（约定）；xlrd å·²è£…å…¥ bundled python（D:\...codex-runtimes\dependencies\python）。

### å…³é”®ç»“论
- è‡ªç ”方向正确，不引入大框架重写；最值得借鉴的是 RuoYi ä»£ç ç”Ÿæˆå™¨ï¼ˆæ‰©å±•æé€Ÿï¼‰ä¸Žå®¡æ ¸è§„则声明式设计（Griffin ç†å¿µï¼‰ã€‚
- å»ºè®®å¼€å·¥é¡ºåºï¼šå…¬è·¯æ—…客 H203-1（高复用、快速见效）→ èƒ½è€— H204（补跨表引用）→ åŸŽå¸‚客运（规则最复杂）→ æŠ•èµ„（独立模块，先定"对接投资系统 vs è§£æžå¸‚州报表"）。

### å¾…办 / ä¸‹ä¸€æ­¥
- ç­‰ç”¨æˆ·ç¡®è®¤å¼€å·¥æ–¹å‘（用户说"先讨论再开工"）。
- è‹¥å¼€å·¥ï¼šå…ˆåš H203-1 è¡¨ç»“构设计 + è§„则初始化 SQL + å‰ç«¯èœå•ã€‚
- æŠ€æœ¯å€ºç™»è®°ï¼šVue2/SB2 å‡çº§ã€ä»£ç ç”Ÿæˆå™¨ã€æ“ä½œæ—¥å¿—注解化（远期）。
- Gitee API æœªè®¤è¯è¿”回空，可人工浏览器补查 gitee æœç´¢ã€‚


## åä¸€ã€äº¤æŽ¥è®°å½•ï¼š2026-08-23（H203-1 å…¬è·¯æ—…客模块已开工并完成主体）

### ç”¨æˆ·ç¡®è®¤çš„ 3 ä¸ªå£å¾„（开工前讨论结论）
1. æŠ¥è¡¨æœŸï¼šä¸»æ¨¡å¼æ²¿ç”¨ã€Œå¹´-月」现算现导（任意历史月份可查），另加「按年」模式（选年份→全年 12 ä¸ªæœˆ+累计+同比），不做预生成。
2. åˆ†å¸‚州明细里的城际城乡公交/巡游出租/网约车：**保留指标行但留空**，表尾加说明行（数据待城市客运模块接入）。
3. è¿æ”¿è½¦è¾†æ•°ï¼šéšæ—…客月报一起导入（同文件第二 sheet），按报表期存储、重复导入覆盖；审核按同报表期匹配。

### æœ¬è½®å·²å®Œæˆï¼ˆå…¨éƒ¨ç»æ ·ä¾‹æ•°æ®è”调验证）
1. **数据库**（docs/init.sql è¿½åŠ ã€Œå…«ã€å…¬è·¯æ—…客运输（H203-1）」段）：
   - æ–°è¡¨ h2031_enterprise_monthly（28 å­—段，对齐样例列）、passenger_auth_vehicle（企业代码/名称/车辆数/载客位数）
   - é¢„ç½® H2031 è§„则 8 æ¡ï¼ˆRULE_P001~P008，report_type=H2031；compare_type æ–°å¢ž MOM_EQ_ZERO/MOM_PCT/MOM_EQ/EXISTENCE）
2. **后端**：
   - å¯¼å…¥ï¼š`DataImportService.importPassengerMonthly`（sheet0 æœˆæŠ¥æŒ‰è¡¨å¤´è§£æž + sheet1 è¿æ”¿å›ºå®š 4 åˆ—；幂等覆盖；只清 H2031 è§„则审核结果，不误删货运结果）；`/api/import/passengerMonthly`
   - å®¡æ ¸ï¼š`AuditEngineService.executePassengerAudit`（4 ç»„规则：运政 DIFF è½¦è¾†Â±3/载客位±50；客运量+周转量环比=0；平均运距环比±10%；包车平均运距=上月；无班线/无包车有量矛盾）；`/api/audit/execute|results` å¢žåŠ  reportType å‚数（H2032/H2031）
   - æŠ¥è¡¨ï¼š`ReportExportService.exportPassengerCityDetail(period, mode)`（month/year ä¸¤ç§æ¨¡å¼ï¼›å½“å¹´ 1-N æœˆæˆ–全年 12 æœˆ + ç´¯è®¡ + åŒæ¯”；自动带出近 3 å¹´åŒºå—；全省=17 å¸‚州汇总；客运量/周转量换算万人、平均运距=周转量/客运量加权）；`/api/report/export/passengerCityDetail?period=&mode=`
   - æ•°æ®æŸ¥çœ‹ï¼š`DataViewController` æ–°å¢ž h2031 / passengerAuth ç±»åž‹
3. **前端**：数据导入加「H203-1旅客月报」；数据查看加「H203-1旅客月报/旅客运政车辆」；审核结果加报表类型切换；报表生成加旅客区块（月报/年报切换）；工作台文案更新
4. **文档**：docs/database.md è¡¥ H203-1 ä¸¤è¡¨ + 14 æ¡è§„则 + æ—…客报表行

### è”调结果（样例 2026 å¹´ 6 æœˆï¼Œ769 å®¶ä¼ä¸šï¼‰
- å¯¼å…¥ï¼š769 è¡ŒæˆåŠŸï¼ˆ5 æœˆ/6 æœˆå„一次，5 æœˆä¸ºæ¨¡æ‹Ÿä¸Šæœˆæ•°æ®ï¼‰
- å®¡æ ¸ 2026-06：共 2057 æ¡é—®é¢˜ï¼Œ6 ç±»è§„则全部触发验证通过（运政对比 67/110、环比=0 å„ 737、包车平均运距=上月 397、无包车有量 4、平均运距环比 5）
- æŠ¥è¡¨ï¼šæœˆæŠ¥ 94 åˆ— / å¹´æŠ¥ 106 åˆ—，累计=5+6 æœˆã€åŒæ¯”与去年区块正确、说明行在
- å‰ç«¯ 4 ä¸ª chunk å·²åŒ…含新页面（js/3,4,5,7.js）

### çŽ¯å¢ƒé‡è¦å˜åŒ–（务必记录）
- æœ¬æœº MySQL 5.7（D:\mysql\mysql-5.7.41-winx64）原来没在跑，且 root å¯†ç ä¸Žé…ç½®ä¸ç¬¦ï¼›å·²ç”¨ --skip-grant-tables é‡ç½® root å¯†ç ä¸º `root` å¹¶æ­£å¸¸å¯åŠ¨åœ¨ **3305**（与 application.yml ä¸€è‡´ï¼‰ã€‚
- traffic_audit åº“原来是无关旧结构（audit_results/reports ç­‰ 5 å¼ è¡¨ï¼‰ï¼Œå·²æŒ‰ README æµç¨‹é‡è·‘完整 docs/init.sql é‡å»ºé¡¹ç›®åº“；遗留旧表 audit_results/audit_rules/report_data/reports æœªåˆ ï¼ˆæ— å®³ï¼‰ã€‚
- å¯åŠ¨ï¼š`powershell -NoProfile -ExecutionPolicy Bypass -File start-dev.ps1`（沙箱内直接 ProcessStartInfo èµ·åŽå°è¢«ç­–略拦截，必须走 start-dev.ps1）。

### å·²çŸ¥è¾¹ç•Œ / å¾…办
- H203-1 ä¼ä¸šè§£é‡Šé¡µï¼ˆExplainReview）仍只列 H2032；旅客 sheet æ— æ ¸å®žè§£é‡Šåˆ—，暂不接解释流程（需求未要求）。
- å®¡æ ¸ç»“果按 reportType è¿‡æ»¤åœ¨å‰ç«¯åˆ‡æ¢ï¼›audit_result.report_id åŒæ—¶å¯æŒ‡å‘ h2032/h2031，attachInfo å·²å…¼å®¹åŒè¡¨ã€‚
- ä¸‹ä¸€æ­¥ï¼šèƒ½è€— H204（车辆粒度，需审核引擎补 CROSS_TABLE è·¨è¡¨å¼•ç”¨è´§è¿æœˆæŠ¥ï¼‰â†’ åŸŽå¸‚客运（TREND/RATIO_CHANGE è§„则 + éƒ¨çº§ä¸‹å‘数据源）→ æŠ•èµ„（先定对接投资系统 vs è§£æžå¸‚å·ž Excel）。
- å¾…用户确认后提交 Git（仓库 Gitee ç§æœ‰ï¼Œè§ç¬¬ä¹èŠ‚）。

### 2026-08-23 IDEA æ‰‹åŠ¨è¿è¡ŒæŠ¥ã€Œæ‰¾ä¸åˆ°æˆ–无法加载主类 com.trafficaudit.TrafficAuditApplication」
- æ ¹å› ï¼šä¸æ˜¯ä»£ç é—®é¢˜ã€‚IDEA çš„ Maven å¯¼å…¥/索引重建尚未完成时点 Run，    raffic-audit-server\target\classes ä¸‹æ²¡æœ‰ç¼–译出的 .class（只剩 yml），Spring Boot è¿è¡Œé…ç½®çš„ Make æ­¥éª¤æ²¡äº§å‡ºï¼Œclasspath é‡Œæ²¡æœ‰ä¸»ç±»ã€‚
- ä¿®å¤ï¼šå‘½ä»¤è¡Œæ‰§è¡Œ cmd /c mvn.cmd -q -f traffic-audit-server\pom.xml compile è¡¥å‡º 55 ä¸ª .class（含 TrafficAuditApplication.class）；停掉了命令行后端链（cmd 33764 / mvn java 28228 / app java 15952，由 start-dev.ps1 å¯åŠ¨ï¼‰ï¼Œé‡Šæ”¾ 8090。
- ç”¨æˆ·å†ç‚¹ IDEA ç»¿è‰² â–¶ å³å¯ï¼›è‹¥ä»å¤±è´¥ï¼šBuild â†’ Rebuild Project，或 File â†’ Invalidate Caches and Restart。
- æ³¨æ„ï¼šç”¨æˆ·è´´çš„运行命令里 Java è·¯å¾„显示 jdk1.8.0\_202（带下划线）是复制显示误差，实际 JDK æ˜¯ C:\Program Files\Java\jdk1.8.0_202（存在，无需改）。
- å‰ç«¯ 8080（node 31196/24168）仍在跑，代理指向 8090；IDEA åŽç«¯ä¸€èµ·å³å¯ç”¨ã€‚

### 2026-08-23 ä¸‹åˆä¼šè¯ï¼šIDEA è·‘通 + æ•°æ®æŸ¥è¯¢å¤±è´¥æŽ’查（已解决）
**最终状态：项目可正常使用，旅客运输数据可导入**
- åŽç«¯æœ€ç»ˆåœ¨ **IntelliJ IDEA** é‡Œè·‘通：用户手动在 IDEA æ‰“开项目后，通过 UI è‡ªåŠ¨åŒ–触发运行（Shift+F10），成功启动 `TrafficAuditApplication`（最终进程 PID 9188，14:42 å¯åŠ¨ï¼Œ8090 ç›‘听）。此后用户可在 IDEA é‡Œç›´æŽ¥ç‚¹ â–¶/■ ç®¡ç†åŽç«¯ã€‚
- å‰ç«¯ï¼š8080 ä¸­é€”掉线，已用 `npm run serve` é‡æ–°æ‹‰èµ·ï¼ˆ`traffic-audit-web/frontend.log` è®°å½•ï¼ŒPID 3324），`/api` ä»£ç†æ­£å¸¸ã€‚
- çŽ¯å¢ƒç¡®è®¤ï¼šIDEA è·¯å¾„ `D:\Development_Tool\IntelliJ IDEA 2020.1.1\bin\idea64.exe`（注意是 `Development_Tool` æ— ä¸‹åˆ’线）；JDK `C:\Program Files\Java\jdk1.8.0_202`；IDEA è¿è¡Œé…ç½® `TrafficAuditApplication`（module=traffic-audit-server）已存在于 `.idea/workspace.xml`，无需新建。

**数据查询失败排查记录（重要，避免下个会话重复踩坑）**
- çŽ°è±¡ï¼šå‰ç«¯ `DataView.vue` æŠ¥ã€Œæ•°æ®æŸ¥è¯¢å¤±è´¥ã€ï¼ŒåŽç«¯ `/api/data/list?type=h2032` ç­‰å…¨éƒ¨ 500（只有 default åˆ†æ”¯çš„ type è¿”回 200）。
- æŽ’查结论：**不是代码/数据库问题**。已核对：7 å¼ è¡¨å…¨éƒ¨å­˜åœ¨ä¸”为空、实体字段与表列完全匹配（脚本逐一对比）、SQL é€»è¾‘正常。
- éªŒè¯æ–¹æ³•ï¼šä¸´æ—¶å‘½ä»¤è¡Œèµ· 8091 è¯Šæ–­å®žä¾‹ï¼ˆ`mvn spring-boot:run` åŠ  `-Dspring-boot.run.arguments="--server.port=8091 ..."`，参数必须用引号包裹、空格分隔），同一份代码所有类型查询全部 200 â†’ æŽ’除代码/DB。
- ç»“果：之后 IDEA å®žä¾‹ï¼ˆåŒä¸€ PID 9188 æœªé‡å¯ï¼‰æ‰€æœ‰ç±»åž‹ä¹Ÿæ¢å¤ 200，判断为**启动初期的临时异常**（可能与 IDEA Make å¢žé‡ç¼–译/classpath å°±ç»ªæ—¶åºæœ‰å…³ï¼‰ï¼Œæ— éœ€ä¿®å¤ä»£ç ã€‚
- å·²éªŒè¯ç±»åž‹ï¼š`h2032 / transportAuth / trackMileage / scaleSplit / freightTurnover / h2031 / passengerAuth`，8090 ç›´è¿žå’Œ 8080 å‰ç«¯ä»£ç†å‡ 200。诊断实例已停（8091 æ— æ®‹ç•™è¿›ç¨‹ï¼‰ã€‚
- è‹¥å†é‡åˆ°åŒç±» 500：先直接 curl `http://localhost:8090/api/data/list?type=h2032` åˆ¤æ–­åŽç«¯çŠ¶æ€ï¼›åŽç«¯æ²¡é—®é¢˜å°±åˆ·æ–°é¡µé¢ï¼›å¿…要时让用户在 IDEA é‡Œ **Build â†’ Rebuild Project** åŽé‡ Run。

**本会话已讨论、待下个会话开工的内容（用户已确认方向）**
1. éœ€æ±‚范围：货运审核规则（已有）+ **公路旅客运输（H203-1，已实现并可导入）** + **城市公交/城市客运** + **投资模块**（用户已把模板放到 `扩展表模板`）。
2. æŠ¥è¡¨ä½“验需求（用户问题 1）：希望**按年/按月动态出表**——不预生成所有表，而是用户查询哪年哪月就生成哪种表，参考报表导出现有模式做动态参数化（月报/年报已在旅客模块实现 `passengerCityDetail?period=&mode=`，可作样板）。
3. åŠŸèƒ½ 2/3（用户问题 2、3）：整体思路参考货运模块的做法（导入→审核→报表 åŒé“¾è·¯ï¼‰ï¼Œå…·ä½“细节待新会话按 `docs/扩展模块评估.md` å±•å¼€ã€‚
4. ç«žå“/开源对比已产出：`docs/开源项目对比.md`（结论：无直接可复用的开源竞品，自研+模块化扩展是合理路线）。
5. ä»£ç ä»æœªæäº¤ Git（Gitee ç§æœ‰ä»“库）——待用户确认后提交。

**下个会话建议从哪开始**
- å…ˆè®©ç”¨æˆ·ç¡®è®¤ä¼˜å…ˆçº§ï¼ša) åŠ¨æ€å¹´/月报表生成（体验优化，改动集中在报表导出）→ b) åŸŽå¸‚公交/城市客运模块 â†’ c) æŠ•èµ„模块。
- è‹¥ä¼šè¯å†æ¬¡å˜é•¿ï¼Œç»§ç»­æŠŠè¿›å±•è¿½åŠ åˆ°æœ¬æ–‡ä»¶æœ«å°¾å¹¶æé†’用户开新会话。

### 2026-08-23 æ™šé—´ä¼šè¯ï¼šæ—…客中口径 3 è¡¨ + èƒ½è€— H204 æ¨¡å—（已完成并验证）
**需求（用户原话）**
1. ã€Šå…¬è·¯æ—…客运输月度生产情况》根据《公路旅客月报》生成：公路旅客分市州明细（已有）+ **中口径明细、中口径排名、中口径分析**（本次新增）。
2. ã€Šé“路货运车辆能源消耗情况（2026年）》根据《第二季度货车能耗明细》与《运政车辆信息》对应字段校验，**有误报出提醒**；无误则生成《能运汇总表》。

**已完成（后端已编译，端到端验证通过）**
- æ•°æ®å¯¼å…¥ï¼š`DataImportService.importEnergyMonthly`（能耗明细 sheet0：每行 5 ç»„×18 åˆ—，列起点 0-based 3/21/39/57/75；运政 sheet1 å›ºå®š 5 åˆ—；码表转中文；幂等删除同 period ä¸¤è¡¨+H204 å®¡æ ¸ç»“果；失败带行号），端点 `POST /api/import/energyMonthly`。实体 `EnergyVehicleQuarterly` çš„ `fuelPer100km` åŠ äº† `@TableField("fuel_per_100km")`（表列名带下划线，曾导致导入全失败）。
- å®¡æ ¸ï¼š`AuditEngineService.executeEnergyAudit`（4 æ¡è§„则已入库：RULE_E001/E002 è½¦è¾†ç±»åž‹/燃料类型 CROSS_DIFF、RULE_E003 æ ‡è®°å¨ä½ CROSS_DIFF threshold=0.05 ä¸”牵引车(码11)用准牵引质量、RULE_E004 EXISTENCE_AUTH è½¦ç‰Œç¼ºå¤±ï¼‰ï¼›`AuditController` å·²åŠ  H204 åˆ†æ”¯ã€‚样例结果 577 æ¡ï¼ˆå¨ä½ 383、运政缺失 192、车辆类型 2）。
- æ±‡æ€»è¡¨ï¼š`ReportExportService.exportEnergySummary(period)` â†’ å…¨çœ + 17 å¸‚州各一张 sheet（按燃料类型分 6 è¡Œ + åˆè®¡ï¼›å¹³å‡å¨ä½=总吨位/车辆数、平均运距=周转量/货运量、百公里单耗=消耗量/总行程*100、周转量单耗=消耗量/周转量*100*系数：柴油0.86*1.4571、汽油0.73*1.4714、LNG/CNG 1.7572、纯电0.1229、氢0.3329*12.1951）。样例导出与模板一致（仅总行程/载货里程比模板示例少 34，经源文件直接求和确认是模板旧数据，非代码问题）。
- æ—…客中口径：`exportPassengerMidDetail/Rank/Analysis(period, mode)`（month/year åŠ¨æ€å‡ºè¡¨ï¼›æ˜Žç»†=客运量块+周转量块各 18 åœ°åŒºÃ—5 æŒ‡æ ‡ï¼›æŽ’名=左块当月+右块 1-N æœˆç´¯è®¡ï¼ŒåŒå—均为客运量/周转量+排名/同比/增速排名；分析=全省累计+同比+占比），端点 `/api/report/export/passengerMidDetail|MidRank|MidAnalysis`。
- å‰ç«¯ï¼š`ReportExport.vue` æ—…客卡片加 3 ä¸ªä¸­å£å¾„按钮 + H204 èƒ½è¿æ±‡æ€»å¡ç‰‡ï¼›`DataImport.vue` åŠ  `energyMonthly` å¯¼å…¥ç±»åž‹ï¼›`AuditResult.vue` åŠ  H204 æŠ¥è¡¨ç±»åž‹ã€‚
- æ–‡æ¡£ï¼š`docs/init.sql` è¿½åŠ ã€Œä¹ã€H204」段（两表 DDL + 4 æ¡è§„则）、`docs/database.md` è¡¥ h204 ä¸¤è¡¨è¯´æ˜Žï¼›`HANDOFF.md` æœ¬æ®µã€‚
- ä¿®å¤ï¼š`AuditEngineService.attachInfo` æ”¹ä¸ºæŒ‰è§„则 reportType åˆ†è¡¨å›žå¡«ä¼ä¸šåç§°ï¼ˆh2032/旅客/H204 ä¸‰è¡¨ id å„自自增，原来 putIfAbsent ä¼šä¸²ä¼ä¸šåï¼‰ã€‚

**当前运行状态（23:31）**
- åŽç«¯ï¼šå‘½ä»¤è¡Œ `start-dev.ps1` å¯åŠ¨ï¼ˆ8090，日志 `backend.log`，PID é“¾ cmd→mvn→java）。**IDEA å®žä¾‹å·²ä¸åœ¨**（无 java è¿›ç¨‹ï¼‰ï¼Œç”¨æˆ·è‹¥è¦å›ž IDEA éœ€ **Build â†’ Rebuild Project** åŽå† Run。
- å‰ç«¯ï¼š`npm run serve` é‡å¯ï¼ˆ8080，PID 15900，日志 `traffic-audit-web\frontend.log`）。
- DB å·²æœ‰ H204 æ ·ä¾‹æ•°æ®ï¼ˆ1284 è¾† + 1114 è¿æ”¿ï¼Œperiod=2026-06）与 577 æ¡å®¡æ ¸ç»“果，页面可直接查看。
- ä¸´æ—¶æ–‡ä»¶ï¼šé¡¹ç›®æ ¹ `energy-test.log`（8091 è¯Šæ–­æ—¥å¿—）保留未删；临时 py è„šæœ¬åœ¨ `%TEMP%\check_*.py`。

**已知边界/决策**
- ä¸­å£å¾„的城际城乡公交/巡游出租/网约车无数据源（等城市客运模块），明细/排名/分析中这些行留空，公路班线=旅客月报一~四类+包车合计；总=四者之和（当前=公路班线）。
- èƒ½è€—车辆类型码→中文采用反推码表（01 æ™®é€š/02 å¹³æ¿/03 ä»“æ …/04 åŽ¢å¼/06 ç½/07 ç‰¹æ®Šç»“æž„/08 è‡ªå¸/09 è½¦è¾†è¿è¾“车/11 åŠæŒ‚牵引车）；审核对比时先去掉运政"重/中/轻型"前缀再按允许集合匹配，避免误报。
- èƒ½è€—汇总只统计能耗明细全部车辆（含运政缺失的），"运政缺失"由审核提醒而非剔除。

**下个会话建议**
- åŸŽå¸‚客运（公交/出租/网约车数据源）→ æŠ•èµ„模块。若用户回 IDEA è¿è¡Œï¼Œéœ€å…ˆ Rebuild。

### 2026-08-24 ä¼šè¯ï¼šæŠ•èµ„模块实拆 + å®žæ–½æ–¹æ¡ˆï¼ˆå¾…用户确认后开工）
**产出**
- å·²å®žæ‹† `docs/扩展表模板/投资/` å…¨éƒ¨æ ·ä¾‹ï¼ˆè¾“出 4 å¼ é¢†å¯¼è¡¨ã€æŠ•èµ„系统导出、市州上报客运/物流报表、全省汇总中间表），结论与方案见 **`docs/投资模块实施方案.md`**（新增）。
- å…³é”®å‘现：
  - æŠ•èµ„系统导出（`查询结果(投资系统-客运+物流 2026.7).xls`）8 åˆ—最干净，但**无市州、无进度/批复字段**，只能做审核比对基准。
  - å¸‚州上报表格式不统一（列数 18~24、.xls/.xlsx/.et/.pdf æ··å­˜ã€æ ‡é¢˜è¡Œä½ç½®ä¸ä¸€ï¼‰ï¼Œéœ€å®¹é”™è§£æžã€‚
  - å…¨çœæ±‡æ€»ä¸­é—´è¡¨ï¼ˆ`6月/7月客运站投资明细表.xlsx`、`6月物流站场投资明细.xls`）**格式统一**，建议一期主入口。
  - 4 å¼ è¾“出表 = åŒä¸€æ‰¹é¡¹ç›® 4 ç§è§†è§’（全省预安排计划 / åäº”五物流重点 / â‰¥1亿规上 / ç»æµŽå¼ºåŽ¿ï¼‰ï¼ŒæŠ½ä¸€å¥—项目主档即可复用。
- æ–¹æ¡ˆè¦ç‚¹ï¼šä¸¤æœŸè½åœ°ï¼ˆM1 å…¨çœæ±‡æ€»å¤§è¡¨å¯¼å…¥+4 å¼ æŠ¥è¡¨ï¼›M2 å¸‚州单表容错解析+系统导出比对审核）；数据模型 `investment_project` + `investment_monthly` ä¸¤å¼ è¡¨ï¼›å®¡æ ¸è§„则 report_type=INVEST（CROSS_DIFF/RANGE/LOGIC/NULL_CHECK）；4 ä¸ªå¯¼å‡ºç«¯ç‚¹ `investPlan/investFiveYearLogistics/investBillion/investCounty`。

**待用户确认（明天开工前）**
1. ä¸»æ•°æ®æºï¼šå…ˆ"全省汇总大表"（M1）还是直接"市州单表解析"？
2. ç³»ç»Ÿå¯¼å‡ºæ˜¯å¦æ¯æœˆéƒ½æœ‰ã€èƒ½å¦æä¾›é¡¹ç›®-市州对照（导出无市州字段）？
3. äº¿å…ƒé¡¹ç›®å£å¾„ â‰¥10000 ä¸‡æ˜¯å¦å‡†ç¡®ï¼Ÿç»æµŽå¼ºåŽ¿æ˜¯å¦æœ‰å›ºå®šåå•ï¼Ÿ

**当前运行状态**
- åŽç«¯ 8090（start-dev.ps1 å¯åŠ¨ï¼Œè·‘含 H204 çš„新代码）、前端 8080（npm run serve，PID 15900）均在跑；H204 æ ·ä¾‹æ•°æ®ä¸Ž 577 æ¡å®¡æ ¸ç»“果在库。
- ä¸´æ—¶æ–‡ä»¶ï¼šé¡¹ç›®æ ¹ `energy-test.log` ä¿ç•™ï¼›`%TEMP%\pyxlrd`（xlrd 2.0.2 ä¸´æ—¶å®‰è£…）、`%TEMP%\dump_xls*.py`、`%TEMP%\check_*.py` ä¿ç•™ã€‚
- çŽ¯å¢ƒå¤‡æ³¨ï¼šç³»ç»Ÿ python çš„ site-packages æ— å†™æƒé™ï¼Œè£…库需 `pip install --target %TEMP%\pyxlrd` åŽ `sys.path.insert`。

**下个会话建议**
- å…ˆè¯·ç”¨æˆ·ç¡®è®¤ä¸Šé¢ 3 ä¸ªé—®é¢˜ â†’ æŒ‰ `docs/投资模块实施方案.md` å¼€å·¥ M1（全省汇总大表导入 + 4 å¼ æŠ¥è¡¨ï¼Œç”¨ 6/7 æœˆæ ·ä¾‹æ ¸å¯¹ï¼‰ã€‚
- è‹¥ç”¨æˆ·æƒ³å…ˆåšåŸŽå¸‚客运，则需先确认网约车拆分口径与部级数据源（此前结论：投资在前、城市客运在后）。

### 2026-08-24 æ™šä¼šè¯ï¼šæŠ•èµ„模块 M1 è½åœ°éªŒè¯ + å®¡æ ¸åŒ¹é…è¯¯æŠ¥ä¿®å¤
**背景**：用户确认 â‘ ä¸»æ•°æ®æºå…ˆæŒ‰â€œå…¨çœæ±‡æ€»å¤§è¡¨â€åšï¼›â‘¡å¸‚州小表主要更新 è‡ªå¼€å§‹å»ºè®¾ç´¯è®¡/自年初累计/本月完成/建设阶段/形象进度 å­—段，并与《查询结果(投资系统-客运+物流 2026.7)》相应字段校验；③4 å¼ è¾“出表为固定格式项目。
**已完成（M1）**
- æ•°æ®æ¨¡åž‹ï¼š`investment_project`(148) + `investment_monthly`(148, 2026-07) + `investment_system`(148) ä¸‰è¡¨ï¼›å¯¼å…¥ç±»åž‹=投资月报（全省汇总大表）+投资系统导出。
- 4 å¼ æŠ¥è¡¨å¯¼å‡ºç«¯ç‚¹å·²è·‘通：`investPlan`(预安排计划进度汇总 247行)、`investFive`(十五五物流 54行)、`investBillion`(亿元项目 2sheet：投资总表+规上项目表 56项)、`investCounty`(经济强县 45行)；样例文件在 `%TEMP%\invest_*.xlsx`。
- å®¡æ ¸è§„则 4 æ¡ï¼ˆRULE_I001~I004，report_type=INVEST）。
**报表内容核对结论（与 docs/扩展表模板/投资/输出/ 7月样例比对）**
- ç»æµŽå¼ºåŽ¿è¡¨ï¼š41 é¡¹ç›®é€è¡Œä¸Žæ ·ä¾‹ä¸€è‡´ï¼ˆæ€»æŠ•èµ„/自开始累计/本年计划/自年初累计/本月完成 0 å·®å¼‚）。
- é¢„安排计划表：内部自洽（29 å¸‚州小计=明细，客运+物流=合计）；83 ä¸ªåŒåé¡¹ç›®æ•°å€¼ä»… 5 å¤„“2026年计划”差异（丹江口右岸/丹江口柑桔/军山矿业/同洲智慧/神农架物流园，源于汇总大表与市州表数据不同）；生成 149 é¡¹ç›® vs æ ·ä¾‹ 167（覆盖差异）。
- åäº”五物流表：35 é¡¹ç›®æ•°å€¼ä¸Žæ ·ä¾‹ 0 å·®å¼‚；样例另有 28 é¡¹ç›®ä¸åœ¨æ±‡æ€»å¤§è¡¨ä¸­ï¼ˆå¾…二期市州单表补）。
- äº¿å…ƒé¡¹ç›®è¡¨ï¼š56 é¡¹ç›®å…¨éƒ¨ â‰¥1亿 ç­›é€‰æ­£ç¡®ã€åˆè®¡è‡ªæ´½ï¼›ä¸Žæ ·ä¾‹ 7 å¤„数值差异均为**样例自身填错**（样例把 è‡ªå¼€å§‹ç´¯è®¡/1-7月累计 è¯¯å¡«åˆ° æ€»æŠ•èµ„/全年计划 åˆ—，生成表用汇总大表正确值）；月度计划/完成列样例有、生成表留空（源数据无）。
**审核匹配误报修复（AuditEngineService æŠ•èµ„部分）**
- ä¿®å¤å‰ 15 æ¡é—®é¢˜ä¸­ 4 æ¡è·¨è¡¨å·®å¼‚为误报：①孝感东城客运换乘中心(更名为…) è¢«æ¨¡ç³ŠåŒ¹é…é”™é…åˆ° éƒ§è¥¿åŽ¿å®¢è¿æ¢ä¹˜ä¸­å¿ƒï¼›â‘¡å’¸ä¸°åŽ¿ç»¼åˆç‰©æµå›­ ä¸Ž ç½—田县综合物流园 å½’一化后同名(“综合物流园”)导致错配。
- ä¿®å¤å†…容：sysMap æ”¹ä¸º å½’一化名→候选列表；精确命中按县区消歧；模糊匹配改“评分取最优”（前缀>中后部包含>5字>子序列），不再首命中返回；归一化增加 â…¡/II ç»Ÿä¸€ï¼›æ–°å¢žå­åºåˆ—兜底（综合枢纽↔综合客运枢纽、物流中心↔物流园中心、智慧/二级站等插入词）。
- ä¿®å¤åŽï¼šRULE_I001/I002/I003 å…¨éƒ¨ 0 è¯¯æŠ¥ï¼›ç¼ºå¤±æé†’ 11→5（丹江口右岸/汉川北站/通山城西/国胜智慧/小河港区Ⅱ期/天门 6 æ¡å·²æ­£ç¡®åŒ¹é…ä¸”数值全同；剩余 5 æ¡ä¸ºçœŸå®žç¼ºå¤±éœ€äººå·¥æ ¸å®žï¼šéƒ‘万高铁巴东综合客运枢纽、唐白河港散货转运中心项目、湖北长江现代物流产业集聚示范区·现代物流园、弘业现代物流产业园、崇阳县国家级综合物流枢纽及配套设施建设项目）。
**当前运行状态**
- åŽç«¯ 8090（start-dev.ps1 é‡å¯ï¼ŒPID 7668，日志 backend.log）、前端 8080（npm run serve，原进程）均在跑；H204 ä¸ŽæŠ•èµ„模块数据都在库。
- ä¸´æ—¶æ–‡ä»¶ï¼š`%TEMP%\invest_*.xlsx`（4 å¼ å¯¼å‡ºéªŒè¯ä»¶ï¼‰ã€`%TEMP%\invest_dump.txt`、`%TEMP%\sample_dump.txt`、`%TEMP%\sample_plan.txt`、`%TEMP%\plan_diff.txt`、根目录 energy-test.log å‡ä¿ç•™ã€‚
**待办**
- M2：17 å¸‚州单表容错解析（补充十五五表缺的 28 ä¸ªé¡¹ç›®ï¼‰+ å¸‚州小表“本月完成/建设阶段/形象进度”字段更新入库。
- 4 å¼ æŠ¥è¡¨ä¸Ž 7 æœˆæ ·ä¾‹å·®å¼‚点（5 å¤„ 2026年计划、预安排覆盖差异、亿元表月度列留空）请用户核对口径。
- äº¿å…ƒè¡¨â€œæŠ•èµ„总表”sheet ç›®å‰ä»…“（五）其他=106.65亿（本年计划合计）”，其余行空白，待确认季度拆分口径。

### 2026-08-24 æ·±å¤œä¼šè¯ï¼šåŸŽå¸‚客运开工讨论（结论：可以做，等数据源）
**用户提问**：现在是否可以加城市客运模块？
**结论**：可以上，且正好补全旅客中口径报表——H203-1 ä¸­å£å¾„明细/排名/分析里一直空着的 åŸŽé™…城乡公交/巡游出租/网约车 ä¸‰è¡Œï¼Œç­‰åŸŽå¸‚客运数据进来即可填上。框架已由投资模块验证（多数据源导入+审核+报表全链路复用），无需新架构。模板 `docs/城市客运/城市客运数据模板.xlsx`（11 sheet：公交/出租/网约车/轨道轮渡/城市分市州/中口径等，含 2026 å¹´ 1-7 æœˆåˆ†å¸‚州数值）。
**开工前需用户确认（按优先级）**
1. å…¬äº¤ã€å·¡æ¸¸å‡ºç§Ÿåˆ†å¸‚州月度原始数据来源（市州上报 or ç³»ç»Ÿå¯æŸ¥ï¼‰â€”—需一份真实数据文件做导入样例（最大前置）。
2. ç½‘约车拆分口径与部级下发文件（模板拆分公式多处 #REF!，放最后做）。
3. â€œå®¢è¿é‡åŒæ¯”环比 0% éœ€æ ¸å®žâ€ä¸šåŠ¡å£å¾„（模板目录同名 txt），确认哪些算正常避免误报。
**建议实施三步（先易后难）**：①公交（4 ç»„规则）先跑通导入+审核+分市州报表；②巡游出租（7 ç»„规则，补 è¿è¥è½¦æ•° vs è¿æ”¿ å¯¹æ¯”，复用 H203-1 è¿æ”¿å¯¹æ¯”）；③网约车拆分（部级数据到位后做，顺手补中口径三表空行）。
**工作量**：后端 6~10 + å‰ç«¯ 2~3 äººå¤©ï¼ˆdocs/扩展模块评估.md）；比投资 M2 å°ã€‚
**下一步**：用户提供公交月度数据文件后开工第 1 æ­¥ã€‚


### 2026-08-24 æ·±å¤œä¼šè¯ï¼ˆç»­ï¼‰ï¼šåŸŽå¸‚客运第 1 æ­¥ï¼ˆå…¬äº¤ï¼‰è½åœ°
**背景**：用户确认公交月度数据源 = `docs/城市客运/导入_城市公共交通月度运营情况（2026å¹´7月）.xls`（实为 xlsx å†…容、.xls æ‰©å±•åï¼Œä¼ä¸šçº§æ˜Žç»† 143 è¡Œï¼Œå«å…¬å…±æ±½ç”µè½¦/轨道/轮渡三类，第 1 æ­¥åªå–公共汽电车字段）；运政数据待用户后补（属出租步骤）。
**已完成（公交 M1）**
- æ•°æ®æ¨¡åž‹ï¼š`city_bus_monthly` è¡¨ï¼ˆä¼ä¸šçº§æœˆåº¦ï¼Œ44 å­—段）；建表+规则 SQL è§ `docs/sql_city_bus.sql`。
- å¯¼å…¥ï¼š`/api/import/cityBus`（period=2026-07 æˆåŠŸ 142 æ¡ã€0 å¤±è´¥ï¼›å¹‚等：同报表期先清旧数据与 CITY_BUS å®¡æ ¸ç»“果；失败显示 Excel è¡Œå·ï¼‰ã€‚市州由 `RegionUtil.cityByCode(所属地区)` æ˜ å°„到 17 å¸‚州。
- å®¡æ ¸ï¼š4 æ¡è§„则（report_type=CITY_BUS，compare_type=TREND_CONSISTENCY / RATIO_CHANGE / AVG_DIST_CHANGE，均为 YELLOW）：
  - RULE_B001 åŸŽå¸‚内与城际城乡客运量趋势一致（环比/同比各一对，趋势不一致且增速>2%）
  - RULE_B002 å®¢è¿é‡ä¸Žæ—…客周转量趋势一致（环比/同比各一对，趋势不一致且增速>2%）
  - RULE_B003 åŸŽå¸‚内/城际城乡客运量占比与上月变化>1%（用文件内环比增速反推上月占比）
  - RULE_B004 å¹³å‡è¿è·çŽ¯æ¯”增减>3 å…¬é‡Œï¼ˆæ–‡ä»¶ç›´è¯»ï¼‰æˆ–城际城乡平均运距变化>3 å…¬é‡Œï¼ˆç”± å‘¨è½¬é‡/客运量 çŽ¯æ¯”反推）
  - 2026-07 å®¡æ ¸ç»“æžœ 53 æ¡ï¼šB001=25、B002=12、B003=15、B004=1（嘉鱼鸿昌城际城乡平均运距 4.8 å…¬é‡Œï¼‰ã€‚
- æŠ¥è¡¨ï¼š`/api/report/export/cityBusDetail` ç”Ÿæˆ_城市公交客运量分市州明细.xlsx（全省+17 å¸‚å·ž Ã— 4 æŒ‡æ ‡ Ã— 1..N æœˆ+月同比+本年累计+上年 1-12 æœˆ+累计）；全省 7 æœˆ 12974.73/87147.68/11508.07/59265.28 ä¸Žæ¨¡æ¿ 0 å·®å¼‚。
- å‰ç«¯ï¼šæ•°æ®å¯¼å…¥é¡µæ–°å¢žã€ŒåŸŽå¸‚公交月报」、数据查看页新增「城市公交月报」、审核结果页新增「CITY_BUS」、报表生成页新增「城市客运报表（公交，第1步）」卡片；均已热更新生效。
**踩坑记录**
- æ•°æ®æ–‡ä»¶æ‰©å±•å .xls ä½†å†…容是 xlsx（ZIP é­”数），openpyxl æŒ‰æ‰©å±•åæ‹’绝——复制成 .xlsx å³å¯ï¼›åŽç«¯ POI `WorkbookFactory` æŒ‰å†…容自动识别，不受影响。
- `start-dev.ps1` ç» `powershell ... | Select-Object` ç®¡é“启动时，后台 cmd/mvn/java ç»§æ‰¿ç®¡é“句柄会导致会话挂起；改为 `*> start-script.log` è¾“出重定向后脚本正常收尾（但会话仍会挂到结束，勿 Ctrl+C ä»¥å…è¯¯æ€åŽç«¯è¿›ç¨‹æ ‘）。另注意：后端曾被 IntelliJ å¯åŠ¨ï¼ˆidea64 ä¸‹çš„ java åº”用进程），按 PID åªæ€åº”用链即可，勿动 idea64。
- MySQL 5.7 çš„ `INSERT ... SELECT ... WHERE NOT EXISTS(派生表列)` æŠ¥ Unknown column，改逐条 `WHERE NOT EXISTS(SELECT 1 FROM audit_rule WHERE rule_code=...)`。
**待办/口径待确认**
- å®¢è¿é‡åŒæ¯”环比 0% éœ€æ ¸å®žï¼ˆ`docs/城市客运/客运量的同比环比是0% éœ€æ ¸å®žï¼ˆä¸»è¦å‡ºçŽ°åœ¨å…¬äº¤ï¼‰.txt`）暂未纳入规则，等业务口径确认。
- å…¬äº¤æŠ¥è¡¨çš„ 2025 å¹´å„月列待 2025 æ•°æ®å¯¼å…¥åŽè‡ªåŠ¨å¡«å……（同比同理由库内上年数据计算）。
- ç¬¬ 2 æ­¥å·¡æ¸¸å‡ºç§Ÿå·²å®Œæˆï¼ˆè§ä¸‹æ–¹è¡¥å……记录）；第 3 æ­¥ç½‘约车拆分等部级数据。
**当前运行状态**
- åŽç«¯ 8090（start-dev.ps1 é‡å¯ï¼ŒPID 12712，日志 backend.log）、前端 8080 å‡åœ¨è·‘ï¼›`city_bus_monthly` å·²æœ‰ 2026-07 æ•°æ®ï¼ˆ142 è¡Œï¼‰ã€‚
- ä¸´æ—¶æ–‡ä»¶ï¼š`%TEMP%\bus_data.xlsx / bus_dump.txt / tpl_dump.txt / city_bus_detail.xlsx / city_bus_report*.txt / dump*.py`、项目根 `start-script.log`、`docs/sql_city_bus.sql`（建表+规则迁移脚本，建议保留）均未删。

### 2026-08-24（续2）：城市客运第 2 æ­¥ï¼ˆå·¡æ¸¸å‡ºç§Ÿï¼‰è½åœ°
**背景**：用户已放入运政数据（`输入_出租车信息(运政车辆信息).xls`，真 OLE .xls，28MB，42636 è¡Œï¼‰ã€‚月报数据源 = `导入_巡游出租汽车运营服务情况月报（2026å¹´7月）.xls`（真 .xls，市州级 17 è¡Œã€41 åˆ—）。
**已完成（巡游出租）**
- æ•°æ®æ¨¡åž‹ï¼š`city_taxi_monthly`（市州月报 41 å­—段）+ `city_taxi_auth`（运政车辆明细）；建表+规则 SQL è§ `docs/sql_city_taxi.sql`（含规则 INSERT，可重复执行）。
- å¯¼å…¥ï¼š`/api/import/cityTaxi`（17 è¡Œ 0 å¤±è´¥ï¼Œå¹‚等清旧+审核结果）；`/api/import/cityTaxiAuth`（42636 è¡Œï¼Œçº¦ 6 åˆ†é’Ÿï¼Œå¹‚等清旧）。市州归属：月报按区划代码（`RegionUtil.cityByCode`，恩施州 422800/神农架 429021 æ­£å¸¸è¯†åˆ«ï¼‰ï¼Œè¿æ”¿æŒ‰ è¯å·â†’档案→经营权→地址 æ­£åˆ™ `(4290\d{2}|42(?:0[1-9]|1[0-3]|28)\d{2})` æå–（实测 42636 è¡Œå…¨éƒ¨å½’市州）。
- å®¡æ ¸ï¼š7 æ¡è§„则（report_type=CITY_TAXI）：
  - RULE_T001 è¿è¥è½¦æ•° vs è¿æ”¿å¯¹æ¯”（CROSS_DIFF_PCT，3%，RED）
  - RULE_T002 åŸŽå¸‚内/城际城乡客运量趋势一致（TREND_CONSISTENCY）
  - RULE_T003 å®¢è¿é‡/周转量趋势一致（TREND_CONSISTENCY，周转量环比由 å®¢è¿é‡çŽ¯æ¯”×平均运距环比 æŽ¨å¯¼ï¼Œcheck_field=turnoverMomDerived）
  - RULE_T004 åŸŽå¸‚内客运量占比变化>1%（RATIO_CHANGE）
  - RULE_T005 å¹³å‡è¿è·å˜åŒ–>3公里（AVG_DIST_CHANGE，城际城乡由上期平均运距=本期−增减反推）
  - RULE_T006 å•è½¦æ¬¡è½½å®¢äººæ•°å˜åŒ–>0.2人（PAX_PER_TRIP_CHANGE，由上期 è½½å®¢è½¦æ¬¡/客运量环比 åæŽ¨ï¼‰
  - RULE_T007 è½½å®¢è½¦æ¬¡/客运量趋势一致（TREND_CONSISTENCY，阈值 0.01）
  - 2026-07 å®¡æ ¸ 6 æ¡ï¼šT001 é»„冈 1931vs2043(5.48%)、神农架 59vs71(16.9%)；T002 æ½œæ±Ÿï¼›T004 å­æ„Ÿ/咸宁/潜江。
- æŠ¥è¡¨ï¼š`/api/report/export/cityTaxiDetail` ç”Ÿæˆ_巡游出租客运量分市州明细.xlsx（全省+17市州×4指标×1..N月+同比+累计+去年12月），全省 7 æœˆ 5860.24/34236.60/5351.24/27422.13 ä¸Ž `巡游出租_模板.xlsx` 0 å·®å¼‚。
- å‰ç«¯ï¼šæ•°æ®å¯¼å…¥é¡µæ–°å¢žã€Œå·¡æ¸¸å‡ºç§ŸæœˆæŠ¥ã€ã€Œå‡ºç§Ÿè½¦è¿æ”¿è½¦è¾†ã€ã€æ•°æ®æŸ¥çœ‹é¡µæ–°å¢žåŒä¸¤é¡¹ã€å®¡æ ¸ç»“果页新增「CITY_TAXI」、报表生成页新增「城市客运报表（巡游出租，第2步）」；均已热更新生效。
**踩坑记录**
- Spring é»˜è®¤ä¸Šä¼ ä¸Šé™ 10MB，28MB è¿æ”¿æ–‡ä»¶è¢«æ‹’ â†’ `application.yml` åŠ  `spring.servlet.multipart.max-file-size/max-request-size=100MB`。
- `audit_result` è¡¨æ—  enterprise_name åˆ—（瞬态字段），`attachInfo` å›žå¡«æ—¶ CITY_BUS/CITY_TAXI è½åˆ° H2032 è¡¨å¯¼è‡´åç§°æ˜¾ç¤ºâ€œåŽŸæ•°æ®å·²é‡æ–°å¯¼å…¥â€å ä½ â†’ å·²ä¿®ï¼šæŒ‰ report_type åˆ†è¡¨å›žå¡«å…¬äº¤ï¼ˆä¼ä¸šåï¼‰/巡游出租（市州名）+核实说明，公交/出租均受益。
- æœˆæŠ¥åŸŽå¸‚字段原用 `normalizeCityName(企业名称)`，恩施“恩施土家族苗族自治州”无法识别 â†’ æ”¹ç”¨ `cityOf(地区代码,名称)` ä¼˜å…ˆæŒ‰åŒºåˆ’代码，并给 RegionUtil å¢žåŠ â€œæ©æ–½åœŸå®¶æ—è‹—族自治州→恩施州”别名。
- è¿æ”¿ 42636 è¡Œé€æ¡ insert æ›¾çº¦ 6 åˆ†é’Ÿï¼Œå‰ç«¯ axios 30s è¶…时导致页面"导入失败"；已改 MyBatis BATCH æ‰¹é‡æ’å…¥ + JDBC `rewriteBatchedStatements=true` + å‰ç«¯ timeout 600000，数据库插入阶段约 30 ç§’（总耗时约 5 åˆ†é’Ÿä¸»è¦åœ¨ 26.8MB xls çš„ POI è§£æžï¼‰ï¼›åŒæŠ¥è¡¨æœŸé‡å¯¼å…ˆåˆ åŽæ’，幂等实测收敛 42636 è¡Œã€‚
**当前运行状态**
- åŽç«¯ 8090（start-dev.ps1 é‡å¯ï¼Œæ—¥å¿— backend.log）：当前进程链 cmd 31740 â†’ mvn(java) 31652 â†’ app(java) 31452（勿误杀；重启时按此链停）；前端 8080（用户进程，勿杀）均在跑；`city_taxi_monthly` 17 è¡Œã€`city_taxi_auth` 42636 è¡Œï¼ˆ2026-07/2026-08 å„ 42636 è¡Œï¼Œ2026-08 ä¸ºä¿®å¤æ‰¹é‡å¯¼å…¥åŽçš„完整重导，非脏数据）。
- ä¸´æ—¶æ–‡ä»¶ï¼š`%TEMP%\taxi_data.xlsx / taxi_dump.txt / yz_stat2.txt / yz_full.txt / city_taxi_detail.xlsx`、根目录 `start-script.log`、`docs/sql_city_taxi.sql` å‡ä¿ç•™æœªåˆ ã€‚
- å¾…办：第 3 æ­¥ç½‘约车拆分（等部级数据）；公交/出租报表的 2025 å¹´å„月列待 2025 æ•°æ®å¯¼å…¥åŽè‡ªåŠ¨å¡«å……。


### 2026-08-24（续3）：城市客运报表改为按模板底稿生成
**需求**：城市客运输出要“根据目录下的模板按照模板生成对应的输出模板”。
**实现**（`ReportExportService`）
- `exportCityBusDetail` / `exportCityTaxiDetail` ä¸å†ä»Žé›¶å»ºè¡¨ï¼Œæ”¹ä¸º `exportCityByTemplate(模板文件名, period, ä»Šå¹´å„月数据, åŽ»å¹´å„月数据)`：读 `docs/城市客运/城市公交_模板.xlsx` / `巡游出租_模板.xlsx` ä¸ºåº•ç¨¿ï¼Œä¿ç•™æ ‡é¢˜/表头/合并单元格（63 å¤„）/边框/数字格式（0.00_）/公式，仅替换数据区市州月度值。
- æ¨¡æ¿ç»“构：Sheet1，row1 æ ‡é¢˜ã€row3-4 è¡¨å¤´ã€æ•°æ®åŒº row5-76（全省+17市州×4指标，每地区 4 è¡Œï¼‰ï¼›2026 æœˆåº¦åˆ— 0-based col2,4,...,14，2025 æœˆåº¦åˆ— col19,21,...,41，同比/累计列为公式（全省行月度列=17市州求和公式）。
- å¡«å……规则：市州行 2026 å¹´ 1..N æœˆæœ‰å€¼å¡« 2 ä½å°æ•°ã€æ— å€¼æ¸…空模板样例；2025 å¹´ 1..12 æœˆåº“内有值填、否则清空（等 2025 æ•°æ®å¯¼å…¥åŽè‡ªåŠ¨å¡«å……并触发同比公式）；全省行与同比/累计公式一律保留；写回前 `FormulaEvaluator.evaluateAll()` é‡ç®—公式缓存值（Excel æ‰“开也可重算）。
- æ¨¡æ¿å®šä½ï¼š`application.yml` æ–°å¢ž `city-passenger.template-dir: docs/城市客运`，`resolveTemplate` æŒ‰ é…ç½®ç›®å½•â†’user.dir→user.dir/.. ä¸‰çº§å›žé€€ï¼›æ•°æ®åŒºè¡Œæ•°å®ˆå«ï¼ˆ<75 è¡ŒæŠ¥é”™é˜²æ¨¡æ¿æ”¹ç‰ˆé”™ä½ï¼‰ã€‚
**验证**：2026-07 å¯¼å‡ºï¼Œå…¨çœ+17市州×4指标（客运量/周转量/城市内客运量/城市内周转量）与库内聚合 0 å·®å¼‚；公交全省 12974.73/87147.68/11508.07/59265.28，巡游出租 5860.24/34236.60/5351.24/27422.13；输出 sheet å/合并单元格/表头与模板完全一致。
**注意**：模板 2026 æ®µåŒæ¯”公式引用 2025 åˆ—，当前 2025 åˆ—无数据，Excel æ‰“开同比显示 #DIV/0!（模板原样行为），2025 æ•°æ®å¯¼å…¥åŽè‡ªåŠ¨ç®—对。


### 2026-08-24（续4）：运政车辆导入"不能导入"修复
**现象**：`导入_出租车信息(运政车辆信息).xls`（26.8MB，42636 è¡Œï¼‰åœ¨æ•°æ®å¯¼å…¥é¡µç‚¹"开始导入"一直失败。
**根因**：
- å‰ç«¯ `src/api/index.js` å…¨å±€ axios `timeout: 30000`，后端旧实现逐条 `insert` çº¦ 6 åˆ†é’Ÿ â†’ 30 ç§’后请求被前端断开，页面报"导入失败"。
- å‰ç«¯ `DataImport.vue` çš„ cityTaxiAuth æ¨¡æ¿æç¤ºåè¯¯å†™ä¸º `输入_...`（实际文件是 `导入_...`）。
**修复**（均已生效）：
- `DataImportService.importCityTaxiAuth` æ”¹ MyBatis BATCH æ¨¡å¼ï¼ˆ`openSession(ExecutorType.BATCH)` + `flushStatements()` + `commit()`），方法加 `synchronized` é˜²å¹¶å‘重复导入；
- `application.yml` JDBC URL åŠ  `rewriteBatchedStatements=true`（批量 flush ç”±çº¦ 4 åˆ†é’Ÿé™è‡³çº¦ 30 ç§’）；
- `DataImport.vue` cityTaxiAuth æ¨¡æ¿åæ”¹å›ž `导入_`，导入请求 `timeout: 600000`。
**验证**：21:57 é‡æ–°å¯¼å…¥ 2026-07，`import_batch` id=31 ä¸º 42636/42636/0，`city_taxi_auth` 2026-07 æ°å¥½ 42636 è¡Œï¼ˆå¹‚等：id=30 ä¸Ž id=31 ä¸¤æ¬¡å¯¼å…¥å‡æ”¶æ•› 42636）；2026-08 æ—§ä»£ç é‡å¤å¯¼å…¥äº§ç”Ÿçš„ 77262 è¡Œè„æ•°æ®å·² DELETE。
**注意**：总耗时约 5.3 åˆ†é’Ÿï¼Œä¸»è¦æ˜¯ POI(HSSF) è§£æž 26.8MB/42636 è¡Œï¼Œä»åœ¨ 600s è¶…时内；如需更快可后续改事件流解析（easyexcel）或拆分文件。
### 2026-08-24（续5）：城市客运报表系列按模板生成（6 è¡¨ + zip）
**需求**：识别《导入_城市公共交通月度运营情况（2026年7月）》《导入_出租车信息(运政车辆信息)》《导入_巡游出租汽车运营服务情况月报（2026年7月）》三份源数据，按目录下模板生成系列输出表；格式（列宽/表头/合并规则）与模板完全一致，仅替换数据。
**目录变化**：模板目录由 `docs/扩展表模板/城市客运` ç§»è‡³ `docs/城市客运`；`application.yml` çš„ `city-passenger.template-dir` å·²åŒæ­¥æ”¹ä¸º `docs/城市客运`（`ReportExportService` çš„ `@Value` é»˜è®¤å›žé€€å€¼ä¸€å¹¶ä¿®æ­£ï¼‰ã€‚
**实现**（`ReportExportService` + `ReportExportController` + `ReportExport.vue`）
- æ•°æ®æ‰©å±•ï¼šå…¬äº¤æºæ–‡ä»¶ï¼ˆä¼ä¸šçº§ 142 è¡Œï¼‰é™¤å…¬å…±æ±½ç”µè½¦å¤–还含**轨道**（武汉 11701.74/周转 96240.86，黄石 30.09/404.37）与**轮渡**（武汉 46.05/156.57）；`city_bus_monthly` åŠ  4 åˆ—（rail/ferry å®¢è¿é‡+周转量），`importCityBus` æ˜ å°„ 0 åŸºåˆ— 13/14/17/18（N/O/R/S）后 142 è¡Œé‡å¯¼æˆåŠŸã€‚
- æ–°å¯¼å‡ºæŽ¥å£ï¼ˆ`/api/report/export/`）：
  - `cityRailFerryDetail`：轨道行 Excel 4/6/8（全省/武汉/黄石，+1 ä¸ºå‘¨è½¬é‡è¡Œï¼‰ï¼Œè½®æ¸¡è¡Œ 13/15；全省月度列保留求和公式。
  - `cityPassengerCitySum`（`城市分市州_模板` / `城市客运各市州明细表_模板`）：客运量区 r5-22、周转量区 r27-44；B=总累计、G=公交、L=出租、Q=网约车（无源数据清空）、V=轨道、X=轮渡；E/J/O/T/W/Y å¢žé€Ÿåˆ—无去年同期 â†’ æ¸…空模板样例。
  - `cityPassengerSummary`（`城市汇总_模板`）：2026 æ®µ B/D å¡«åº“内累计、C/E åŒæ¯”清空、网约车行置 0；2025/2024 æ®µï¼ˆG..Q åˆ—）保留模板历史参考值不动。
  - `cityPassengerSeries`：一键 zip（公交/出租/轨道轮渡明细 + åˆ†å¸‚州累计 + å„市州明细表 + æ±‡æ€»ï¼‰ã€‚
- å‰ç«¯ `ReportExport.vue` æ–°å¢žâ€œåŸŽå¸‚客运报表（系列）”卡片（4 ä¸ªå•è¡¨æŒ‰é’® + ä¸€é”®æ‰“包 zip）。
**POI 0 åŸºæ•™è®­**：POI è¡Œå·æ˜¯ 0 åŸºï¼Œä¹‹å‰æŒ‰ Excel 1 åŸºå†™å¯¼è‡´æ•´å—错位一行（轨道读到 96645.23 ç­‰é”™ä½å€¼ï¼‰ï¼›å·²æ”¹ 0 åŸºï¼ˆè½¨é“ 3/5/7、轮渡 12/14、分市州 4/26、汇总 2..8），重生成后数据全部核对通过。
**验证（2026-07）**：轨道 æ­¦æ±‰ 11701.74/96240.86、黄石 30.09/404.37；轮渡 å…¨çœ=武汉 46.05/156.57；分市州累计 æ­¦æ±‰ B=17060.44（=公交 4218.74+出租 1093.91+轨道 11701.74+轮渡 46.05）、黄石 B=1254.8、林区 B=27.15；汇总 æ€»å®¢è¿é‡ B3=30612.85、公交 12974.73、出租/巡游 5860.24、轨道 11731.83、轮渡 46.05；2025/2024 æ®µä¸Žæ¨¡æ¿ä¸€è‡´ï¼›è¡¨å¤´/合并/列宽全部 MATCH（仅数据行按设计替换）。
**输出**：`docs/城市客运/输出/生成_城市公交客运量分市州明细.xlsx`、`生成_巡游出租客运量分市州明细.xlsx`、`生成_轨道轮渡客运量分市州明细.xlsx`、`生成_城市客运客运量分市州累计.xlsx`、`生成_城市客运各市州明细表.xlsx`、`生成_城市客运汇总.xlsx` å…± 6 ä¸ªæ–‡ä»¶ã€‚
**坑（脚本编码）**：`%TEMP%\gen_series2.ps1` è‹¥ç”¨æ—  BOM çš„ UTF-8 ä¿å­˜ï¼ŒPowerShell 5.1 æŒ‰ ANSI è¯»å–会把中文路径读成乱码，复制到 `D:\鏂囨。\ChatGPT\traffic-audit\docs\...`（本次误建的乱码目录，未删）；已用带 BOM ç‰ˆæœ¬é‡å†™ï¼ŒçŽ°æ­£ç¡®å†™å…¥ `docs\城市客运\输出`。



### 2026-08-25 ä¸Šåˆä¼šè¯ï¼šåŸŽå¸‚客运链路恢复验证 + æ•°æ®åº“连接根因修复
**现象**：新对话启动前后端（start-dev.ps1 ç¡®è®¤ 8090/8080 å°±ç»ªï¼‰åŽï¼Œ`/api/data/list` å…¨éƒ¨ç±»åž‹ 500、`/api/audit/results` 500；仅 default åˆ†æ”¯ï¼ˆinvestment*）返回 200 ç©ºæ•°æ®ã€‚
**排查**：后端是 IDEA å¯åŠ¨å®žä¾‹ï¼ˆæ—¥å¿—不进 backend.log），起 8091 è¯Šæ–­å®žä¾‹ï¼ˆ`mvn spring-boot:run -Dspring-boot.run.arguments=--server.port=8091`）复现，堆栈根因：
- `java.sql.SQLNonTransientConnectionException: Public Key Retrieval is not allowed`（HikariPool åˆå§‹åŒ–失败）。
- æœ¬æœº MySQL 8 root è®¤è¯æ’件为 `caching_sha2_password`（mysql å®¢æˆ·ç«¯å¯è¿žï¼‰ï¼ŒJDBC URL ç¼º `allowPublicKeyRetrieval=true` â†’ éž SSL è¿žæŽ¥æ‹’绝取公钥。
**修复**：`application.yml` / `application.yml.example` / `target/classes`（同步）JDBC URL åŠ  `allowPublicKeyRetrieval=true`（保留 rewriteBatchedStatements=true）；停 IDEA æ—§å®žä¾‹ â†’ start-dev.ps1 é‡å¯ â†’ å…¨éƒ¨ç±»åž‹ 200。
**恢复验证（全部与 08-24 è®°å½•ä¸€è‡´ï¼‰**：
- é‡è·‘审核：CITY_BUS 2026-07 = 53 æ¡ï¼ˆB001=25/B002=12/B003=15/B004=1）；CITY_TAXI 2026-07 = 6 æ¡ï¼ˆT001=2/T002=1/T004=3）。之前公交 53 æ¡è¢« 23:21 çš„ 142 è¡Œé‡å¯¼ï¼ˆå¹‚等清结果）冲掉且未重跑；出租库里残留的是 2026-08 çš„ 6 æ¡ã€‚
- 6 å¼ æŠ¥è¡¨é‡æ–°ç”Ÿæˆï¼ˆ`docs/城市客运/输出/`），关键数值全部核对：公交全省 12974.73/87147.68/11508.07/59265.28；出租武汉 1093.91/8532.5；轨道武汉 11701.74/96240.86、黄石 30.09/404.37；轮渡 46.05/156.57；分市州累计 æ­¦æ±‰ B=17060.44/黄石 1254.8/林区 27.15；汇总 æ€» 30612.85/公交 12974.73/出租 5860.24/轨道 11731.83/轮渡 46.05；系列 zip 6 æ–‡ä»¶é½å…¨ã€‚
**小修复（与 HANDOFF 08-24 è®¾è®¡ä¸ç¬¦å¤„）**：`setDataCell` å¯¹ `v==0` æ‰§è¡Œ `c.setBlank()`，导致汇总表"网约车行置 0"实际输出为空；新增 `setZeroCell`（显式写 0.0）用于 B7/D7，重生成后 B7=0、D7=0，其余数值不变。
**待办不变**：城市客运第 3 æ­¥ï¼ˆç½‘约车拆分）等部级数据源；公交 2025 å„月列等 2025 æ•°æ®å¯¼å…¥ï¼›"客运量同比环比 0% éœ€æ ¸å®ž"（txt ä¸ºç©ºï¼‰ç­‰ä¸šåŠ¡å£å¾„；中口径三表（H203-1 æ˜Žç»†/排名/分析）的 åŸŽé™…城乡公交/巡游出租 è¡Œå¯åœ¨åŸŽå¸‚客运数据基础上接入（建议下一步，需确认口径：公交取 passengerChengxiang å­—段，出租源文件无城际城乡客运量字段需确认拆分口径）。
**坑**：apply_patch åœ¨æœ¬çŽ¯å¢ƒå…¨éƒ¨æŠ¥ "Access is denied"（连根目录文件也拒），改用 PowerShell `[System.IO.File]::ReadAllText/WriteAllText`（UTF-8 æ—  BOM）编辑；`mvn spring-boot:run` ä¸ä¼šè‡ªåŠ¨é‡æ‹· resources，改 yml åŽéœ€æ‰‹åŠ¨åŒæ­¥ target/classes æˆ–è·‘ `mvn compile`。


### 2026-08-25 ä¸‹åˆä¼šè¯ï¼šæŠ¥è¡¨ç”Ÿæˆ/企业解释/数据导入 UI é‡æž„（用户确认口径后开工）
**需求**：①城市客运报表在报表生成页合并为一个模块；②页面美化 + æŠ¥è¡¨å¯é€‰ç”Ÿæˆ/一键全部 + æ”¯æŒä¸€ä¸ªæœˆ/几个月/一年；③企业解释加入公路旅客与城市客运（能耗/投资无解释，不做）；④数据导入界面优化；⑤货运/旅客/投资等模块同步统一。
**后端新增/修改**（已编译重启，8090 å°±ç»ªï¼‰
- `ReportExportService`：新增 `exportFreightSeries` / `exportPassengerSeries` / `exportInvestSeries` / `exportSelectedSeries`（前端「生成选中」多选时按 type åˆ—表打包 zip，避免浏览器拦截多个下载）；`REPORT_FILE_NAMES` æ˜ å°„ 18 å¼ è¡¨ã€‚
- `ReportExportController`：新增 `/export/freightSeries`、`/export/passengerSeries`、`/export/investSeries`、`/export/selected?types=a,b,c&mode=` å››ä¸ª zip ç«¯ç‚¹ï¼›å…¨éƒ¨å¯¼å‡ºç«¯ç‚¹åŠ  `logExport` ç•™ç—•ã€‚
- æ–°å¢ž `OperationLog` å®žä½“ + `OperationLogMapper` + `OperationLogService`（自动从 Authorization å¤´è§£æžç”¨æˆ·ã€X-Forwarded-For å– IP），写入 `sys_operation_log`（表原本为空，现已有记录）。
- `ExplainController`：`/api/explain/list` åŠ  `reportType` å‚数，支持 H2032/H2031/CITY_BUS/CITY_TAXI å››ç±»ï¼Œè¿”回类型对应列。
- `DataImportController`：新增 `GET /api/import/batches?type=&limit=`（导入批次历史，`import_batch` è¡¨ï¼‰ã€‚
- `DbQueryExecutor`：白名单注册 `h2031_enterprise_monthly` / `city_bus_monthly` / `city_taxi_monthly`（AI å¯¹è¯å¯æŸ¥ï¼‰ï¼›`LLMService` ç³»ç»Ÿæç¤ºæ”¯æŒ context ä¼ å…¥ `reportType`/`tableName` å¼•å¯¼æŸ¥è¡¨ã€‚
**前端（vue-cli çƒ­æ›´æ–°å·²ç”Ÿæ•ˆï¼‰**
- `ReportExport.vue` é‡å†™ï¼šäº”个模块（货运/旅客/能耗/投资/城市客运）统一卡片布局（grid），城市客运 6 å¼ è¡¨åˆå¹¶ä¸ºä¸€å¼ å¡ï¼›æ¯æ¨¡å— checkbox å¤šé€‰ + ã€Œç”Ÿæˆé€‰ä¸­ã€ï¼ˆå•é€‰ç›´ä¸‹ã€å¤šé€‰æ‰“包 zip）+「一键生成全部(zip)」；旅客保留月报/年报两档（年报选年份，period=yyyy&mode=year）；底部使用提示说明期数口径（选 07=1~7 æœˆã€é€‰ 12=全年+上年同比）。
- `ExplainReview.vue`：报表类型下拉（货运/公路旅客/城市公交/巡游出租），表格列按类型动态显示，关键字标签随类型切换（出租按市州）；AI åˆ†æž context å¢žåŠ  reportType/tableName。
- `DataImport.vue`：导入类型按 è´§è¿/公路旅客/能耗/城市客运/投资 äº”组分区展示；右侧导入设置卡；下方「最近导入记录」表格（类型/期/文件名/总行数/成功/失败/时间，来自 /import/batches）；cityTaxiAuth æ˜¾ç¤ºçº¦ 5 åˆ†é’Ÿè€—时提示。
**验证（全部通过）**
- `/api/import/batches`：正常返回最近 10 æ¡ã€‚
- `/api/explain/list`：H2032=28 æ¡ï¼ˆ2026-07）、H2031=0、CITY_BUS=109、CITY_TAXI=8（神农架等 8 å¸‚州有解释）。
- zip：selected（cityBusDetail+cityTaxiDetail+cityPassengerSummary）、freightSeries、passengerSeries（month/year）、investSeries æ–‡ä»¶é½å…¨ï¼›æ—…客年报 104810/47498 å­—节（>月报 95824/43439，正确）。
- ç•™ç—•ï¼šsys_operation_log å·²è®°å½• 6 æ¡ã€ŒæŠ¥è¡¨ç”Ÿæˆã€ï¼ˆæœªç™»å½•æ—¶ userId ä¸ºç©ºï¼Œdetail ä¸º UTF-8 ä¸­æ–‡æ­£å¸¸ï¼‰ã€‚
- å‰ç«¯ chunk 7/4/1 å·²åŒ…含新代码（report/export/selected、import/batches、reportType ç­‰æ ‡è®°ï¼‰ï¼Œæ— ç¼–译错误。
**说明/边界**
- èƒ½è€—模块只有 1 å¼ è¡¨ï¼Œä¸æ˜¾ç¤ºã€Œä¸€é”®ç”Ÿæˆå…¨éƒ¨ã€ã€‚
- ã€Œå‡ å¹´ã€ç»´åº¦ï¼šå›ºå®šæ¨¡æ¿è¡¨åªæ”¯æŒå½“å¹´ 1~12 æœˆ + ä¸Šå¹´åŒæ¯”两段（领导表格式），多年对比如需可后续加非模板「区间明细导出」。
- ä¼ä¸šè§£é‡Š H2031 å½“前 0 æ¡æ˜¯å› ä¸ºæ ·ä¾‹æ•°æ®è¯¥æœŸæœªå¡«è§£é‡Šï¼ŒæŽ¥å…¥é€»è¾‘本身已通。
- apply_patch ä»ä¸å¯ç”¨ï¼ˆAccess denied），前端大文件用 Python æ•´æ–‡ä»¶é‡å†™ï¼Œå°æ”¹åŠ¨ç”¨å­—符串替换。



### 2026-08-25 æ™šä¸Šä¼šè¯ï¼šæœˆæŠ¥/年报全模块 + èƒ½è€—模板化 + ä¼ä¸šè§£é‡Šæœªå¡«å†™ + æŠ¥è¡¨é¡µä¸‹æ‹‰å¯¼å‡ºï¼ˆç”¨æˆ·ç¡®è®¤å£å¾„后实施）
**需求**：①布局改为 è´§è¿â†’公路旅客→城市客运（旅客右边）→能耗→投资；②月报/年报切换加到 è´§è¿/旅客/城市客运/投资；③生成内容改多选下拉框 + å•æŒ‰é’®ã€Šå¯¼å‡ºã€‹ï¼›â‘£æ•°æ®å¯¼å…¥ç•Œé¢è¿›ä¸€æ­¥ç¾ŽåŒ–；⑤企业解释加“未填写”与过滤开关；⑥硬性要求：货运/旅客/投资/客运新表必须与【格式模板】列宽/表头/合并规则完全一致，仅替换数据，导出 Excel。
**后端（已编译重启验证）**
- å¹´æŠ¥ mode æ‰©å±•ï¼š`monthOf(period, mode)`（year→12）；`exportCityDetail/exportFreightRank/exportTurnoverRank`、`exportCityBusDetail/exportCityTaxiDetail/exportCityRailFerryDetail/exportCityPassengerCitySum/exportCityPassengerSummary`、`exportCityByTemplate`、`investPlan/investFiveYearLogistics/investBillion/investCounty` åŠä¸‰ä¸ª series ä¸Ž `selectedReportData` å…¨éƒ¨åŠ  mode é€ä¼ ï¼›æŽ§åˆ¶å™¨ 16 ä¸ªç«¯ç‚¹åŠ  `mode` å‚数。货运年报标题显示「报表期：2026年全年」。
- èƒ½è€— `exportEnergySummary` æ”¹ä¸ºæ¨¡æ¿åº•ç¨¿ï¼š`docs/公路旅客+能耗/模板_能运汇总表 .xlsx`（新增 `energy.template-dir` é…ç½® + `resolveAnyTemplate`），保留标题/表头/合并(A1:M1、A11:G11)/公式(D/J/L/M ä¸Žåˆè®¡ SUM)/列宽/样式，仅填数值列（B/C/E/F/G/H/I/K）；全省 + 17 å¸‚å·ž clone sheet；季度标题改中文数字（2026年第二季度）。
- æŠ•èµ„ 4 è¡¨åŽ»æŽ‰ `autoWidth`：与 7 æœˆæ ·ä¾‹ä¸€è‡´ï¼ˆæ ·ä¾‹ 0 åˆå¹¶ã€æ— è‡ªå®šä¹‰åˆ—宽，表头/内容 08-24 å·²éªŒè¯é€è¡Œä¸€è‡´ï¼‰ã€‚
- `ExplainController`：默认返回全部记录（含空解释），新增 `hasExplanation=true` è¿‡æ»¤ï¼›`DataImportService.importPassengerMonthly` è¡¥è§£æžã€Œæ ¸å®žæ€§åŽŸå› è§£é‡Šã€åˆ—（当前源文件 28 åˆ—无此列 â†’ H2031 å…¨éƒ¨æ˜¾ç¤ºâ€œæœªå¡«å†™â€ï¼Œå±žæºæ•°æ®é—®é¢˜ï¼‰ã€‚
**前端（chunk 1/7 å·²å«æ–°ä»£ç ï¼‰**
- `ReportExport.vue` é‡å†™ï¼šæ¨¡å—顺序 è´§è¿â†’公路旅客→城市客运→能耗→投资（grid：货运整行，旅客左/城市客运右，能耗左/投资右）；生成内容 = el-select å¤šé€‰ä¸‹æ‹‰ï¼ˆå…¨é€‰/清空）+ å•æŒ‰é’®ã€Œå¯¼å‡ºã€ï¼ˆé€‰ 1 å¼ ç›´ä¸‹ã€å¤šå¼  zip，按钮显示张数）；货运/旅客/城市客运/投资均有月报/年报 radio（能耗保持季度末月）。
- `ExplainReview.vue`：「仅显示已填写」el-switch（→ hasExplanation）+ ç©ºè§£é‡Šæ˜¾ç¤ºã€Œæœªå¡«å†™ã€warning æ ‡ç­¾ã€‚
- `DataImport.vue`：默认报表期=当前月；批次表加成功/失败着色与「状态」列（成功/部分失败/无数据）；每类型加一句导入说明。
**验证（全部通过）**
- explain：H2031 æ— è¿‡æ»¤ 771 / è¿‡æ»¤ 0；H2032 è¿‡æ»¤ 28；CITY_BUS 142；CITY_TAXI 17。
- èƒ½è€—：18 sheets（全省+17 å¸‚州），标题「2026年第二季度能耗汇总情况表」，公式/合并保留，武汉柴油车 375 ç­‰æ•°å€¼æ­£ç¡®ã€‚
- å¹´æŠ¥ï¼šè´§è¿ 28 åˆ—（12 æœˆ+同比）、城市公交 45 åˆ—（2026 12 æœˆ+2025 12 æœˆï¼‰ï¼›`selected?period=2026&mode=year&types=...` zip 4 æ–‡ä»¶æ­£å¸¸ã€‚
- å‰ç«¯ç¼–译成功（Compiled successfully），chunk 1/7 å« hasExplanation/select-wrap/exportChecked æ ‡è®°ã€‚
**坑**
- åˆ†æ®µæ›¿æ¢ï¼ˆPython）时 `c.find()` æ‰¾åˆ°æ—©äºŽç›®æ ‡çš„行导致文件复制出一整段城市客运代码 â†’ ç¼–译报“重复方法”+ Lombok è¿žé”æŠ¥é”™ â†’ ç”¨è¡Œç´¢å¼•ç²¾ç¡®åˆ é™¤é‡å¤å— [2033..2560) åŽ `mvn clean compile` é€šè¿‡ã€‚教训：批量替换后必须 clean compile + æ£€æŸ¥æ–¹æ³•å”¯ä¸€æ€§ã€‚
- start-dev.ps1 è‹¥ä¸Šæ¬¡ä¼šè¯æœªé€€å‡ºï¼ˆ`*>` é‡å®šå‘被后台子进程持有句柄）会并发重复启动 â†’ å…ˆç¡®è®¤ 8090/8080 ç©ºç«¯å£å†å¯åŠ¨ï¼›backend.log åˆ¤å°±ç»ªè¦ç¡®è®¤æ˜¯æ–°å†™å…¥å†…容（旧日志会误判 OK）。
**待办 / éœ€ç”¨æˆ·æä¾›**
- ã€æ ¼å¼æ¨¡æ¿ã€‘基准文件：货运输出表（货运量分市州明细/货运量排名/周转量排名）与旅客输出表（分市州明细 + ä¸­å£å¾„ 3 è¡¨ï¼‰ç›®å‰ä»“库无输出格式模板（`docs/货运` åªæœ‰è¾“入模板与 08-04 ç”Ÿæˆä»¶ï¼›`模板_交企统H203-1表` æ˜¯ç©ºå£³ï¼‰ï¼Œéœ€ç”¨æˆ·æä¾›åŸºå‡†æ–‡ä»¶æ‰èƒ½åšâ€œä»…替换数据”改造；城市客运（8 æ¨¡æ¿ï¼‰ã€èƒ½è€—（1 æ¨¡æ¿ï¼‰ã€æŠ•èµ„（7月样例 4 .xls）已按模板/样例对齐。
- æŠ•èµ„ DB å½“前仅 50 æ¡ 2026-07 æœˆåº¦æ•°æ®ï¼ˆ41 ä¸ªç»æµŽå¼ºåŽ¿é¡¹ç›®ä»… 1 æ¡æœ‰æœˆåº¦æ•°æ®ï¼‰ï¼Œéœ€é‡æ–°å¯¼å…¥å®Œæ•´æŠ•èµ„月报才能生成完整报表（报表逻辑正常，是数据量问题）。
- æ—…客中口径的城际城乡公交/巡游出租/网约车行仍待城市客运口径接入。

### 2026-08-25（续5，调研测试）：用户更新旅客输入/输出样例 + æŠ•èµ„校验需求（待确认口径后实施）
**用户改动（本次会话开头发现）**
- å…¬è·¯æ—…客输入 `docs/公路旅客+能耗/公路旅客简化工作.xlsx` æ›´æ–°ï¼ˆ11:21，707KB），现含 6 sheet：公路旅客6月报（28列×770行，仍无核实性原因解释列）、运政车辆数、公路旅客分市州明细/中口径明细/中口径排名/中口径分析（4 ä¸ªå†…嵌样例）。
- æ–°å¢ž `docs/公路旅客+能耗/输出/` 4 å¼ **模板格式样例**（用户手工基准，非程序生成）：
  - `生成_公路旅客分市州.xlsx`：58行×284列、237 åˆå¹¶ï¼›r4-7=全省(客运量/周转量/个体客运量/个体周转量)，r8 èµ· 17 å¸‚å·ž 2~4 è¡Œä¸ç­‰ï¼ˆæ­¦æ±‰/鄂州/荆州/恩施/仙桃/潜江/天门/林区无个体行）；C..O=2026å¹´1-6月+累计、R..AP=2025å¹´12月+累计、AS..=2024 å…¨å¹´ï¼›åŒæ¯”/累计=公式，历史值样例自带。
  - `生成_中口径明细.xlsx`：188行×43列、143 åˆå¹¶ï¼›å®¢è¿é‡å— r5-94 + å‘¨è½¬é‡å— r99-188，各=全省+17市州×5指标(总/班线/公交/出租/网约车)；数据区 **2378 ä¸ªå¤–部引用公式**（`[1]班线包车!C8`、`[1]公交!C9-[1]公交!C11`、`[1]出租!`、`[1]网约车!`）指向 `D:\王琴的工作文件\客货运月度数据汇总\2026å¹´\6月\2026å¹´6月客运量、货运量(111)1.xlsx`；内部公式 4818 ä¸ªï¼ˆåŒæ¯”/累计）。
  - `生成_中口径排名.xlsx`：20行×9列**单块累计**（市州/客运量/排名/同比/增速排名/周转量/排名/同比/增速排名，RANK+SUM å…¬å¼ï¼Œæ ‡é¢˜"2026å¹´1-6月全省分市州累计完成道路客运生产情况"）——注意工作簿内嵌 sheet æ˜¯åŒå—(当月+累计18列)，独立样例改成单块，需与用户确认按哪种生成。
  - `生成_中口径分析.xlsx`：7行×8列、1 åˆå¹¶ï¼›æ€»/班线/公交/出租/网约车 Ã— ç´¯è®¡å®¢è¿é‡/同比/占比 + ç´¯è®¡å‘¨è½¬é‡/同比/占比（总=23496.1693/0.0777、周转 917059.1993/-0.0295）。
- æŠ•èµ„新增 3 ä¸ª 0 å­—节需求 txt：①投资输入要与《模板_查询结果(投资系统-客运+物流 2026.7)》校验、不一致弹窗；②按 6/7 æœˆæ–‡ä»¶å¤¹å¸‚州报表更新《6/7月物流站场投资明细》项目和数据；③按 6/7 æœˆæ–‡ä»¶å¤¹æ›´æ–°ã€Šæ›´æ–°_6/7月客运站投资明细表》两张大表（用户原文疑似笔误，应为 6月/7月两张）。
**测试结果（前后端均在跑：8090/8080）**
- æ—…客导入新 xlsx：`POST /api/import/passengerMonthly` â†’ 769 æ¡æˆåŠŸ+767 è¿æ”¿ï¼Œ0 å¤±è´¥ï¼›`/api/data/list?type=h2031&period=2026-07` total=769 âœ“ï¼›cityBus=142、cityTaxi=17 âœ“。
- æ—…客 4 è¡¨å½“前导出结构全部与样例不符：分市州 401×96/0合并 vs 58×284/237；中口径明细 191×96/0 vs 188×43/143；排名 18列双块 vs 9列单块；分析 7×8/0合并 vs 7×8/1合并 â†’ éœ€å…¨éƒ¨æŒ‰æ ·ä¾‹æ¨¡æ¿åŒ–。
- æŠ•èµ„校验：`POST /api/audit/execute?reportType=INVEST&period=2026-07` â†’ 2 æ¡ PENDING（RULE_I004 éƒ‘万高铁巴东综合客运枢纽投资系统缺失；RULE_I003 å¤©é—¨å¸‚物流中心本月完成 3058 vs æŠ•èµ„系统 600，绝对差2458/相对差409.7%）✓ æ ¡éªŒæ•°æ®å·²å…·å¤‡ï¼ˆinvestment_project/monthly/system å„ 148 æ¡ï¼‰ï¼Œ**前端弹窗未实现**。
- æŠ•èµ„ 4 è¡¨å¯¼å‡º investPlan/FiveYearLogistics/Billion/County å…¨éƒ¨ OK âœ“（08-24 å·²éªŒè¯ä¸Ž 7 æœˆæ ·ä¾‹ä¸€è‡´ï¼‰ã€‚
**待用户确认口径后实施**
1. æ—…客 4 è¡¨æ¨¡æ¿åŒ–（仿 `exportCityByTemplate`）：以 `docs/公路旅客+能耗/输出/` 4 å¼ ä¸ºåº•ç¨¿ï¼Œä¿ç•™è¡¨å¤´/合并/列宽/行高/样式/内部公式，数据区填库内值；**外部引用公式必须替换为数值**（源文件 `王琴的工作文件` ä¸åœ¨é¡¹ç›®å†…，否则打开断链弹更新）；生成后 `FormulaEvaluator.evaluateAll()` é‡ç®—缓存值。
2. éœ€ç¡®è®¤ï¼šåˆ†å¸‚å·ž"个体客运量/周转量"行数据源（输入无个体字段）；中口径 å‡ºç§Ÿ/网约车 åŸŽé™…城乡口径（样例出租 3131.95/网约车 2063.45 ä¸ºç”¨æˆ·å‚考值，DB æ— æ­¤å­—段，公交有 passengerChengxiang/turnoverChengxiang å¯å¡«ï¼‰ï¼›æŽ’名表按单块累计还是当月+累计双块。
3. æŠ•èµ„弹窗：DataImport.vue å¯¼å…¥æŠ•èµ„月报后调 audit/execute?reportType=INVEST，有 PENDING å¼¹çª—列差异明细。
4. æŠ•èµ„输入更新 M2：解析 6/7 æœˆæ–‡ä»¶å¤¹å¸‚å·ž xls æŠ¥è¡¨â†’按项目名更新《更新_6/7月客运站/物流站场投资明细》字段（自开始累计/自年初累计/本月完成/建设阶段/形象进度），需先定匹配键与覆盖策略，建议 1 å¸‚州原型。
**临时产物**：`_test_passenger/`（4 å¼ æ—…客现导出 + 4 å¼ æŠ•èµ„现导出，对比用）。

### 2026-08-25（续6，实施完成）：旅客 4 è¡¨æ¨¡æ¿åŒ– + ä¸ªä½“客运量导入 + æŠ•èµ„校验弹窗（用户已拍板 3 å£å¾„）
**口径确认**：①中口径明细跨簿公式→替换为库内数值（2025 åˆ—保留模板缓存值）；②分市州"个体客运量/周转量"行=用户导入个体数据后按市州聚合填充；③中口径排名=单块累计（选 1 ä¸ªæœˆå‡ºå½“月、1-6 æœˆå‡ºç´¯è®¡ï¼‰ã€‚
**后端（已编译重启验证）**
- `application.yml` æ–°å¢ž `passenger.template-dir: docs/公路旅客+能耗/输出`；`ReportExportService` 4 ä¸ªæ—…客导出方法全部改为模板底稿生成（保留表头/合并/列宽/公式/样式，仅替换数据）：
  - åˆ†å¸‚州：2026 å¹´ 1..6 æœˆåˆ—填库内班线客运量/周转量（metric 0/1），个体行填个体导入数据，2025/2024 åŽ†å²åˆ—保留模板值，累计/同比/全省行公式保留重算。
  - ä¸­å£å¾„明细：数据区 2378 ä¸ªè·¨ç°¿å¼•ç”¨å…¨éƒ¨æ›¿æ¢â€”—2026 æœˆåº¦åˆ—填库内值（班线=h2031、公交=cityBus åŸŽé™…城乡、出租/网约车=显式 0），2025 åˆ—替换为模板缓存值（去年数据不丢），累计/同比/总行公式保留重算。
  - ä¸­å£å¾„排名：单块累计，标题随报表期（1 æœˆ="2026å¹´1月…"，1-6 æœˆ="2026å¹´1-6月…累计"，年报="1-12月…"）；B/D/F/H å¡«å€¼ï¼ŒRANK/SUM å…¬å¼ä¿ç•™ã€‚
  - ä¸­å£å¾„分析：B/C/F/G å¡«å€¼ï¼ˆæ€»/班线/公交/出租/网约车累计+同比），占比公式保留。
- æ–°å¢žä¸ªä½“客运量导入：表 `passenger_individual_monthly`（period/region_code/enterprise_code/enterprise_name/passenger_count/turnover），接口 `POST /api/import/passengerIndividual`（POI è§£æžåˆ—名含"个体客运量/个体周转量"，同 period å¹‚等），实体/Mapper `PassengerIndividualMonthly`。
- æ–‡ä»¶åç»Ÿä¸€ä¸ºæ ·ä¾‹åï¼šç”Ÿæˆ_公路旅客分市州.xlsx、生成_中口径明细.xlsx、生成_中口径排名.xlsx、生成_中口径分析.xlsx（REPORT_FILE_NAMES + series zip + å‰ç«¯åŒæ­¥ï¼‰ã€‚
**前端（chunk 4/7 å·²å«æ–°ä»£ç ï¼‰**
- `DataImport.vue`：公路旅客组新增「个体客运量/周转量」导入；投资月报（客运/物流）导入成功后自动调 `audit/execute?reportType=INVEST`，有 PENDING å¼¹çª—列出差异明细（规则名/项目/实际/基准/差异），无差异提示一致。
- `ReportExport.vue`：旅客 4 å¼ é€‰é¡¹åä¸Žæ ·ä¾‹ä¸€è‡´ï¼Œæç¤ºè¯­æ›´æ–°ã€‚
**验证（全部通过）**
- 4 å¼ è¡¨ dims/合并单元格与样例完全一致（分市州 58×284/237、中口径明细 188×43/143、排名 20×9/1、分析 7×8/1），外部引用残留 0。
- æ•°å€¼æŠ½æŸ¥ï¼šæ­¦æ±‰ 6 æœˆç­çº¿å®¢è¿é‡ 341.1759/周转量 19301.074（与样例一致）；黄石个体客运量 3.0/周转量 150.0（导入 30000 äºº/150 ä¸‡äººå…¬é‡Œï¼‰ï¼›2025 åˆ—保留模板值且转数值（R11=255.17）；全省行公式重算正确（周转量 K åˆ— 112416.37）。
- ä¸ªä½“导入：4 æ¡æˆåŠŸ 0 å¤±è´¥ï¼Œé‡å¤å¯¼å…¥å¹‚等；测试数据已清理（DB 0 æ¡ï¼‰ã€‚
- å¹´æŠ¥æ¨¡å¼ï¼šæ ‡é¢˜"2026å¹´1-12月…"正确。
- æŠ•èµ„校验：2 æ¡ PENDING（郑万高铁巴东枢纽缺失、天门物流 3058 vs 600）→ å‰ç«¯å¼¹çª—数据源就绪。
**踩坑（重要）**
- **POI 5.2.5 `Cell.setCellValue(double)` å¯¹å…¬å¼å•å…ƒæ ¼åªæ›´æ–°ç¼“存值、不移除公式**！写入前必须先 `setBlank()` å† `setCellValue`；显式 0 éœ€æ“ä½œåº•å±‚ XML（`getCTCell().setT(N).setV("0")`）。中口径明细外部引用替换因此返工一次。
- åˆ†å¸‚州模板周转量/个体行 A åˆ—为空（合并单元格只写首行）→ è¡Œè¯†åˆ«é¡»ç”¨ B åˆ—指标 + å‰ä¸€ä¸ªéžç©º A åˆ—（currentRegion），否则这些行被跳过保留模板样例值。
- åŽŸ `metricValue(agg, 1)` è¿”回客运量（0/1 å£å¾„相同）→ åˆ†å¸‚州周转量行直接取 `agg.turnoverTotal/10000`。
- å…±äº«å…¬å¼åˆ¤æ–­ï¼šPOI `getCellFormula()` å±•å¼€æ­£å¸¸ï¼Œä½† `keepCached`/`fillMidCell` å¿…须先读缓存值再 setBlank（顺序不可反）。
**待办**：①分市州/中口径明细模板仅 1-6 æœˆåˆ—，7-12 æœˆéœ€ç”¨æˆ·ä¸‹åŠå¹´æ¨¡æ¿ï¼›â‘¡ä¸­å£å¾„出租/网约车城际城乡数据源待接入（现显式 0）；③投资 M2（按 6/7 æœˆæ–‡ä»¶å¤¹å¸‚州报表更新《更新_6/7月客运站/物流站场投资明细》）未开工，需定匹配规则；④DB æŠ•èµ„月度仅 50 æ¡ 2026-07（investment_monthly），完整报表需补导入。

### 2026-08-25（续7）：模板一致性全量核查 + è´§è¿ 3 è¡¨æ¨¡æ¿åŒ–改造（已完成验证）
**用户要求**：核查 åŸŽå¸‚客运/货运/能耗/板块（旅客/投资）导出是否满足「与导入模板的列宽、表头、合并规则完全一致，仅替换数据，导出 Excel」。
**核查结论（14 å¼ å…¨éƒ¨ PASS）**
- åŸŽå¸‚客运 6 å¼ ï¼ˆå…¬äº¤/巡游出租/轨道轮渡/分市州累计/各市州明细/汇总）：结构完全一致（含 63/63/95/18/18/4 åˆå¹¶ã€åˆ—宽、表头）；数据差异均为口径所致（选当月/累计、同比清空、网约车显式 0）。
- å…¬è·¯æ—…客 4 å¼ ï¼ˆåˆ†å¸‚å·ž/中口径明细/排名/分析）：结构完全一致（237/143/1/1 åˆå¹¶ï¼‰ã€‚
- èƒ½è€— 1 å¼ ï¼šå…¨çœ Sheet1 ä¸Ž `模板_能运汇总表 .xlsx` å®Œå…¨ä¸€è‡´ï¼ˆåˆå¹¶ 2、列宽 5）；另按需求生成 17 å¸‚å·ž sheet；标题改回模板的「第X季度」（原代码写「X季度」）。
- è´§è¿ 3 å¼ ï¼š**本次从零建表改造为模板底稿生成**（模板=`docs/货运/生成_*.xlsx`，与 `货运简化工作.xlsx` åŒç»“构）：
  - åˆ†å¸‚州明细：以模板为底稿，填 C~M æœˆåº¦å€¼/同比 + O/P ç´¯è®¡/累计同比；月度列仅 1-6 æœˆï¼ˆæ¨¡æ¿å›ºå®šï¼‰ï¼Œç´¯è®¡åˆ—按所选期 1..N æœˆï¼ˆN>6 æ—¶æœˆåº¦åˆ—仍只显示 1-6 æœˆï¼Œä¸Žæ—…客口径一致，7-12 æœˆå¾…下半年模板）。
  - è´§è¿é‡æŽ’名/周转量排名：以模板为底稿，填 B~P（规上/规下/合计 + æŽ’名/占全省比重/同比/增速排名）；货运量 Q/R å æ¯”公式保留不动，周转量 Q/R æŒ‰æ–°æ•°æ®é‡ç®—。
  - æŽ’名表补上了原先缺失的 è§„上同比/规下同比（全省+市州；规下同比=模板去年合计-H2032去年规上）。
- æ–°å¢ž `freight.template-dir: docs/货运` é…ç½®ï¼ˆapplication.yml）+ `resolveFreightTemplate`。
- ä¿®å¤è¿‡ç¨‹ä¸­å‘现的坑：POI åˆ—号 0-based å·®ä¸€åˆ—（月度值写到 B/D/F/..，已修正为 C/E/G/..）；写值前须 setBlank（POI å…¬å¼å•å…ƒæ ¼åªæ›´æ–°ç¼“存）。
**验证方式**：`_test_check2/v5_*.xlsx`（14 å¼ çŽ°å¯¼å‡ºï¼‰é€ä¸€ä¸Žæ¨¡æ¿å¯¹æ¯” dims/合并集合/列宽集合，全部 PASS；抽查排名表 2026-07 è§„上数据落位正确（全省 186.8988、武汉 72.9224 æŽ’名 1、占全省比重 0.3902）；能耗标题=2026年第二季度能耗汇总情况表。
**注意**：货运 DB å½“前仅 h2032 æœ‰ 2026-07 æ•°æ®ï¼ˆ40 æ¡ï¼‰ï¼Œ`freight_turnover_import`/`scale_split_transport` ä¸ºç©º â†’ æ˜Žç»†/排名现导出大部分为空（仅规上行有值），属数据未导入，非格式问题；用户需先导入《模板_货运量周转量》《规上规下拆分表》。
**待办不变**：①模板仅 1-6 æœˆåˆ—，7-12 æœˆéœ€ä¸‹åŠå¹´æ¨¡æ¿ï¼ˆè´§è¿/旅客同）；②投资 4 è¡¨ä»ä¸ºä»£ç è‡ªå»ºå¸ƒå±€ï¼ˆæ ·ä¾‹ä¸º .xls æ— åˆå¹¶/无自定义列宽，暂与样例对齐），未纳入模板底稿。

### 2026-08-25（续8）：投资 4 è¡¨æ”¹ä¸ºã€Œæ¨¡æ¿åº•ç¨¿åŽŸä½æ›¿æ¢ã€ï¼ˆå·²å®ŒæˆéªŒè¯ï¼‰
**用户要求**：公路旅客、城市客运、能耗、投资四个模块必须按【格式模板】的列宽、表头、合并规则完全一致生成，仅替换数据，导出 Excel。
**本轮改造（ReportExportService.java，`traffic-audit-server/src/main/java/com/trafficaudit/reportexport/service/ReportExportService.java`）**
- `investPlan`（全省预安排计划进度情况汇总，约 2380 è¡Œèµ·ï¼‰ï¼šé€è¡Œæ‰«æ R5~末尾，按 åˆè®¡è¡Œ/块标题行/市州小节/分组标题/项目行 åˆ†ç±»ï¼›æœªåŒ¹é…é¡¹ç›®æ•´è¡Œæ¸…空（保留合并样式）；`一、客运站场基础设施建设`→客运站场块、`二、交通物流基础设施建设`→物流园区块、`三、老旧营运货车报废更新`→整块清空（无数据源）。
- `investFiveYearLogistics`（十五五规划物流项目，约 2511 è¡Œèµ·ï¼‰ï¼šsheet1 å…¨é‡åŽŸä½æ›¿æ¢ï¼ˆ85×248/99 åˆå¹¶ï¼‰ï¼›sheet0（月2）仅更新日历标题（模板 sheet0 æœ¬èº«æ— æ ·ä¾‹æ•°æ®ï¼‰ã€‚
- `investBillion`（亿元投资）：上轮已为模板底稿，保持（17×6/2 + 80×24/25）。
- `investCounty`（经济强县，约 2659 è¡Œèµ·ï¼‰ï¼šéåŽ† R4 èµ·æŒ‰ B åˆ—项目名匹配，未匹配保留空白。
- æ–°å¢žè¾…助方法（约 2710 è¡Œèµ·ï¼‰ï¼š`nvl`/`blankInvestRow`（setBlank 0..lastCol ä¿ç•™æ ·å¼/合并）/`templateCityFull`（模板短名→规范市州，含 æž—区/恩施 åˆ«åï¼Œèµ° RegionUtil）/`isCityLabel`/`matchInvest`（先按类别/市州过滤候选，再评分取最优）/`normInvestName`/`investNameScore`（归一化精确>前缀包含>中后部包含>5字>子序列>LCS å…œåº•ï¼›åŽ¿åŒºå‰ç¼€ä¸ä¸€è‡´æ‰£ 400；归一化同名且模板带县区但候选不含→拒绝，避免 å®œéƒ½â†”当阳 è¯¯é…ï¼‰/`isInvestSubsequence`/`investLcs`/`extractInvestCounty`。
- `writeInvestAggHssf`：移除 col12（自筹）写入（无数据源），保留 7/8/9/22/23。
**验证（全部通过）**
- ç»“构对比 `_shots/cmp_invest2.py`：4 è¡¨ dims/合并/列宽与模板完全一致（investPlan 272×38/111；investFiveYearLogistics sheet0 32×24/33 + sheet1 85×248/99；investBillion 17×6/2 + 80×24/25；investCounty 65534×256/57）PASS。
- æ•°æ®è½ä½ `_shots/dump_data_check.py`：全省合计、市州小节、项目数据、老旧货车段清空、五五表合计行清空、强县表项目及备案号写入均正确。
- åç§°åŒ¹é…è´¨é‡ `_shots/sim_match3.py`：PLAN 130/183、FIVEYEAR 40/63、COUNTY 41/41；未匹配均为“模板样例有但汇总大表/DB æ— â€çš„项目（老旧货车段、农村站亭、武汉天河综合客运枢纽、荆州市铁水联运物流中心等），属数据缺失非误配。
- äº§ç‰©ï¼š`_shots/invest_out2/`（4 .xls + selected4.zip）；本轮 API å¤æµ‹ï¼š`GET /api/report/export/selected?period=2026-07&mode=month&types=investPlan,investFiveYearLogistics,investBillion,investCounty` æ­£å¸¸è¿”回 zip（4 æ–‡ä»¶é½å…¨ï¼Œå‘½åæ­£ç¡®ï¼‰ã€‚
**前端现状确认（本轮核对，无需再改）**
- æŠ¥è¡¨ç”Ÿæˆé¡µï¼šç¬¬ä¸€æŽ’ è´§è¿/公路旅客/城市客运，第二排 èƒ½è€—/投资；生成内容多选下拉+全选/清空+单「导出」按钮（1 å¼ ç›´æŽ¥ä¸‹è½½ã€å¤šå¼ æ‰“包 zip）；月报/年报 å•é€‰é½å…¨ã€‚截图 `_shots/report_page.png`。
- æ•°æ®å¯¼å…¥é¡µï¼šæŠ¥è¡¨æœŸå¡ç‰‡ + è´§è¿/公路旅客/城市客运/能耗/投资五个下拉框（模块选择），上传/导入/最近记录齐全。
- ä¼ä¸šè§£é‡Šé¡µï¼š4 ç±»æŠ¥è¡¨å­—段完整（企业名称/车辆数/客运量/周转量/平均运距/企业解释等），无“只能看到企业名”问题。
- æ•°æ®æŸ¥çœ‹ï¼šè½¨è¿¹é‡Œç¨‹/货运量周转量/H203-1/城市公交月报/巡游出租月报 å‡æœ‰ã€Œå…¨å±æŸ¥çœ‹ã€ã€‚
- å¯†ç åŠ å¯†ï¼šsys_user.admin å·²æ˜¯ BCrypt（60 ä½ï¼‰ï¼Œæ»¡è¶³â€œè´¦å·åŠ å¯†å­˜å‚¨â€éœ€æ±‚。
**遗留**：①老旧货车报废更新块/五五表合计行无数据源（等二期数据）；②货运 DB ç¼ºã€Šæ¨¡æ¿_货运量周转量》《规上规下拆分表》导入，明细/排名导出大部分为空（格式正常，数据未导入）；③模板仅 1-6 æœˆåˆ—，7-12 æœˆéœ€ä¸‹åŠå¹´æ¨¡æ¿ï¼ˆè´§è¿/旅客同）；④投资 M2（市州单表解析）未开工。


### 2026-08-25（续9）：HANDOFF.md æ¢å¤ + ä¸‹ç­å‰æ”¶å°¾ï¼ˆå·²å®Œæˆï¼‰
**事件**：本会话中 HANDOFF.md æ›¾è¢«è¯¯è¦†ç›–（一条 PowerShell WriteAllLines å‘½ä»¤å›  AddRange(Object[]) ç±»åž‹é”™è¯¯å¤±è´¥ï¼Œ`$result` åªå‰©æ–°å¤´è¡Œ â†’ æ–‡ä»¶è¢«è¦†ç›–成 506 å­—节），随后一次有 bug çš„重放又把它污染成 28,084 å­—节（「十节」重复）。
**恢复方法（已完成并验证）**：从 4 ä¸ªä¼šè¯ JSONL æ—¥å¿—重放 31 æ¡åŽ†å²å†™å…¥å‘½ä»¤åˆ°æ²™ç›’ `_shots/handoff_replay/`（必须用 pwsh 7.6.4 + è·¯å¾„替换修复版脚本，路径含反斜杠需用 chr(92) æ‹¼æŽ¥é¿å…è¢« Python è§£æžæˆè½¬ä¹‰ï¼‰ï¼Œé€å­—校验：base ä¸Ž 08-22 åŽŸæ–‡ä¸€è‡´ã€æ–‡ä»¶å¤´å°¾ä¸Žç ´åå‰è¯»å–快照一致、各步输出与原始输出对齐。已恢复为 74,447 å­—节（原 74,547，差 100 å­—节/52 å­—符为中间段空白级差异，日志已截断无法恢复，不影响内容）。污染版备份在 `_shots/HANDOFF.md.polluted_1633.bak`（保留未删）。
**下班前收尾**：已用 `start-dev.ps1` å®Œæ•´é‡å¯å‰åŽç«¯å¹¶éªŒè¯ï¼š
- åŽç«¯ 8090 å°±ç»ªï¼ˆæ—¥å¿— backend.log，`Started TrafficAuditApplication` + `Tomcat started on port(s): 8090`，PID 30380，HTTP 200）。
- å‰ç«¯ 8080 å°±ç»ªï¼ˆæ—¥å¿— traffic-audit-web/frontend.log，`Compiled successfully` + `App running at:`，PID 23624，HTTP 200）。
- IDEA æœ¬ä½“在运行（idea64.exe，11:00 å¯åŠ¨ï¼‰ï¼›åŽç«¯å½“前由命令行/start-dev ç®¡ç†ï¼Œè‹¥æƒ³æ”¹å›ž IDEA ç®¡ç†ï¼šå…ˆåœ¨ IDEA Run é…ç½®é€‰ `TrafficAuditApplication` ç‚¹ â–¶ï¼ˆä¼šå ç”¨ 8090，需先停命令行实例），或直接用脚本重启。
**下次开工建议**：先读 AGENTS.md + æœ¬æ–‡ä»¶ï¼›ç¡®è®¤æŠ•èµ„ M2（市州单表解析）优先级；遗留事项见续8（货运明细/排名缺数据源、模板仅 1-6 æœˆåˆ—、老旧货车报废更新块等二期）。


### 2026-08-26 å‡Œæ™¨ä¼šè¯ï¼šæ•°æ®åº“清空 + ç”¨æˆ· 4 é¡¹æ„è§å¤„理（已完成验证）
**用户指令**：①所有输出文档必须与【格式模板】列宽/表头/合并完全一致、仅替换数据；②逐模块核对需求（点名：巡游出租规则 7 æ¡ç•Œé¢åªæ˜¾ç¤º 4 æ¡ã€èƒ½è€—规则没看）；③企业解释行间距太大；④重复导入是否会存两份。
**0. æ•°æ®åº“清空（用户要求）**
- 26 å¼ è¡¨ TRUNCATE å…¨æ¸…（表结构保留、自增重置），备份 `_shots/db_backup_20260826_004520.sql`（28,115,426 å­—节，含全库结构与数据）。
- æ¸…空后已恢复 `audit_rule`：从备份提取原 33 æ¡ + æ–°å¢ž H204 6 æ¡ = 39 æ¡ã€‚`sys_role`(4)/`sys_dept`/`sys_user` æœªæ¢å¤ï¼ˆåŽŸ sys_user æœ¬å°± 0 è¡Œï¼›éœ€è¦æ—¶ä»Žå¤‡ä»½æˆ– init.sql é‡æ–°åˆå§‹åŒ–）。
**1. æ¨¡æ¿ä¸€è‡´æ€§ï¼ˆæ ¸å¿ƒä¿®å¤ï¼šè·¯å¾„配置错误）**
- å‘现：`application.yml` çš„ `passenger.template-dir: docs/公路旅客+能耗/输出` æŒ‡å‘**不存在**的目录（实际目录 `docs/公路旅客/输出`）；能耗无 `energy.template-dir` é…ç½®ï¼ˆé»˜è®¤ `docs/公路旅客+能耗` åŒæ ·ä¸å­˜åœ¨ï¼‰ï¼›ä»£ç è¯»èƒ½è€—模板 `模板_能运汇总表 .xlsx` è€Œç”¨æˆ·å‡Œæ™¨æ›´æ–°çš„是 `docs/能耗/生成_能运汇总表.xlsx`（00:24~00:43 ç”¨æˆ·æ‰¹é‡æ›´æ–°äº†è´§è¿ 3 å¼  + æ—…客 4 å¼  + èƒ½è€— 1 å¼ æ¨¡æ¿ï¼‰ã€‚
- ä¿®å¤ï¼š`application.yml` â†’ passenger=docs/公路旅客/输出、新增 energy=docs/能耗；`ReportExportService` èƒ½è€—模板名改为 `生成_能运汇总表.xlsx`。
- éªŒè¯ï¼š10 å¼ å¯¼å‡ºï¼ˆè´§è¿ 3 + æ—…客 4 + èƒ½è€— 1 + åŸŽå¸‚公交/巡游出租）调用 `/api/report/export/*` å…¨éƒ¨ 200，用 openpyxl å¯¹æ¯”模板与导出：sheet ç»´åº¦/合并单元格数/列宽 å…¨éƒ¨ PASS；投资 4 è¡¨ zip（selected）正常返回（结构此前已验）。
**2. å®¡æ ¸è§„则核对**
- CITY_TAXI：`sql_city_taxi.sql` ä¸Žæ¸…空前 `audit_rule` å‡ 7 æ¡ï¼ˆRULE_T001~T007），`AuditEngineService` å¼•æ“Ž 5 ç§ compareType å…¨éƒ¨å®žçŽ°ï¼ˆå« T003 å‘¨è½¬é‡çŽ¯æ¯”推导、T006 å•è½¦æ¬¡è½½å®¢äººæ•°åæŽ¨ã€T007 è½½å®¢è½¦æ¬¡ä¸Žå®¢è¿é‡è¶‹åŠ¿ï¼‰ã€‚“界面只有 4 æ¡â€åŽŸå› ï¼šå®¡æ ¸ç»“果页只显示**触发的问题记录**，未触发的规则看不到；且原规则管理页是空壳 `<div>规则管理</div>`、后端无规则 API。→ å·²å®žçŽ°è§„则管理页（见下）。
- H204 èƒ½è€—：需求 7 æ¡ï¼ŒåŽŸåªå®žçŽ° 4 æ¡ï¼ˆE001~E004，E004 ä¸ºéœ€æ±‚外补充）。**新增 RULE_E005~E010**（引擎 `checkEnergyLoadedRatio/FuelRange/FuelMom/VsFreightReport/AvgDistVsFreight/LoadedTonnageRatio` + `prevQuarter`/`fuelPer100kmMedian` è¾…助；`executeEnergyAudit` å¢žåŠ ä¸Šä¸€å­£åº¦çŽ¯æ¯”基准与 H2032 ä¼ä¸šæœˆæŠ¥åŸºå‡†ï¼›`docs/init.sql` è¡¥ç§å­ï¼›å·²å…¥åº“）。
- è§„则管理页：新增 `RuleManageController.java`（GET /api/rules/list、POST /api/rules/toggle、POST /api/rules/update）+ é‡å†™ `RuleManage.vue`（6 ç±»æŠ¥è¡¨ç±»åž‹åˆ‡æ¢ã€è§„则全列表、阈值可编辑、等级可选、启用开关）。
**3. ä¼ä¸šè§£é‡Šè¡Œé«˜**
- `ExplainReview.vue`：表格 `size="mini"` + è¡Œé«˜ 32px + å•å…ƒæ ¼ padding 3px；解释列 `max-height:62px` å†…部滚动，不再把行撑得过高。
**4. é‡å¤å¯¼å…¥å¹‚等确认**
- åŽç«¯æ‰€æœ‰å¯¼å…¥æ–¹æ³•ï¼ˆH2032/H2031/个体/能耗/运政/轨迹/规上规下/货运周转量/投资/系统导出/公交/出租/出租运政）均为「同报表期先删旧数据+清理对应审核结果再插入」，重复导入**不会存两份**；`import_batch` æ¯æ¬¡å¯¼å…¥è®°ä¸€æ¡å±žæ“ä½œç•™ç—•ï¼ˆé¢„期）。
- å‰ç«¯ `DataImport.vue` æŒ‰é’® `:loading` é˜²è¿žç‚¹ï¼›`importCityTaxiAuth` æœ‰ `synchronized`，其余方法无锁（单用户实际无并发问题，如需强一致可加）。
**当前运行状态**
- åŽç«¯ 8090 å·²ç”¨ start-dev.ps1 é‡å¯åŠ è½½æ–°ä»£ç ï¼ˆbackend.log `Started TrafficAuditApplication` + `Tomcat started on port(s): 8090`，HTTP 200；`/api/rules/list?reportType=H204` è¿”回 10 æ¡ï¼‰ã€‚
- å‰ç«¯ 8080 åœ¨è·‘（frontend.log `Compiled successfully` + `App running at:`，热更新已加载 RuleManage/ExplainReview æ–°é¡µé¢ï¼‰ã€‚
- éªŒè¯äº§ç‰©ï¼š`_shots/verify_export/`（10 å¼ å¯¼å‡º + invest_selected.zip）、`_shots/cmp_struct2.py`、`_shots/cmp_width.py`、`_shots/extract_rules.py`、`_shots/old_audit_rule.sql`、`_shots/patch_*.py` å‡ä¿ç•™ã€‚
**遗留/待办**：①投资 M2（市州单表容错解析）仍未开工（素材在 `docs/投资/输入/` é½å¤‡ï¼‰ï¼›â‘¡7-12 æœˆæ¨¡æ¿éœ€ç”¨æˆ·æä¾›ä¸‹åŠå¹´æ¨¡æ¿ï¼ˆæˆ–确认自行扩展 1-6 æœˆæ¨¡æ¿ï¼‰ï¼›â‘¢è´§è¿ã€Šæ¨¡æ¿_货运量周转量》《规上规下拆分表》未导入（明细/排名导出数据为空）；④老旧货车报废更新块/五五表合计行无数据源；⑤数据库已清空，业务数据与 `sys_role`/`sys_user` éœ€é‡æ–°åˆå§‹åŒ–；⑥能耗新 6 æ¡è§„则的阈值（中位数±50%、环比±50%、月报对比 50%/60% ç­‰ï¼‰è¯·ç”¨æˆ·ç¡®è®¤å£å¾„。


### 2026-08-26 ä¸Šåˆä¼šè¯ï¼šå®¡æ ¸ç»“果页体验优化（keep-alive + æŒ‰æ¡æ˜Žç»†å¡ç‰‡è§†å›¾ï¼Œå·²å®ŒæˆéªŒè¯ï¼‰
**用户 2 ä¸ªé—®é¢˜**：①点「数据」链接跳转 DataView è¿”回后，审核结果丢失需重新点「执行审核」；②「按条明细」界面太丑、企业和问题都看不全。
**本轮改动（纯前端，无需后端）**
- `traffic-audit-web/src/App.vue`：`<router-view />` å¤–包 `<keep-alive include="AuditResult">`，跳转「数据/解释」再返回时组件实例被缓存，报表期/过滤条件/审核结果/选中状态原样保留，不再需要重新执行审核。
- `traffic-audit-web/src/views/AuditResult.vue`：按条明细由 el-table æ”¹ä¸ºã€Œä¸€æ¡é—®é¢˜ä¸€å¼ å¡ç‰‡ã€ï¼š
  - å¡ç‰‡å¤´éƒ¨ï¼šå‹¾é€‰æ¡† + ä¼ä¸šåï¼ˆå®Œæ•´å±•ç¤ºï¼‰+ æŠ¥è¡¨æœŸ + ç­‰çº§ tag + çŠ¶æ€ tag + ã€Œæ•°æ®/解释」链接 + ç¡®è®¤/忽略按钮；
  - å¡ç‰‡ä¸»ä½“：规则名 + è§„则编码 + å®žé™…/基准/差异 ä¸‰è¡Œï¼ˆæµ…灰底分组展示，长文本自动换行）；
  - é¡¶éƒ¨å·¥å…·æ åŠ ã€Œå…¨é€‰å½“前 N æ¡ã€ï¼ˆå«åŠé€‰æ€ indeterminate），配合原有批量确认/忽略；
  - çº¢è‰²é—®é¢˜å¡ç‰‡å·¦è¾¹æ¡†çº¢è‰²ã€é»„色左边框橙色、已处理卡片整体淡化，列表区独立滚动。
- æ•°æ®åŠ è½½æ—¶ç»™æ¯æ¡ç»“果初始化 `_selected:false`（保证 el-checkbox å“åº”式），批量选择改为 `filteredResults.filter(r => r._selected)` å®žæ—¶è®¡ç®—。
**验证**：frontend.log `Compiled successfully in 678ms`（热更新生效，10:31:11）；页面路由跳转/返回状态保留逻辑由 keep-alive ä¿è¯ã€‚
- è¿½åŠ ï¼ˆ10:42）：用户反馈问题区域仍偏小 â†’ æ–°å¢žã€Œèšç„¦æŸ¥çœ‹ã€æ¨¡å¼ï¼ˆ`focusMode`）：一键隐藏统计卡/筛选栏/规则统计/h3 æ ‡é¢˜ï¼Œä»…留报表类型+报表期+按钮一行 + é—®é¢˜åˆ—表占满（`main-focus` æ”¶ç´§å†…边距）；退出聚焦还原。frontend.log `Compiled successfully in 1103ms`（10:42:30）。patch：`_shots/patch_focus_mode.py`。
**产物**：`_shots/patch_detail_view.py`（本轮 patch è„šæœ¬ï¼Œä¿ç•™ï¼‰ã€‚
**遗留/待办不变**：投资 M2 ä»æœªå¼€å·¥ï¼ˆç´ æåœ¨ `docs/投资/输入/` é½å¤‡ï¼‰ï¼›7-12 æœˆæ¨¡æ¿å¾…用户提供或确认扩展；货运《模板_货运量周转量》《规上规下拆分表》未导入（明细/排名导出数据为空）；能耗新 6 æ¡è§„则阈值口径待用户确认。


### 2026-08-26 ä¸Šåˆä¼šè¯ï¼ˆç»­2）：数据导入模块补全旅客/能耗运政独立导入（已完成验证）
**用户反馈**：数据导入页「公路旅客」下拉只有月报+个体两项（货运却有 5 é¡¹ï¼‰ï¼Œã€Œèƒ½è€—」只有 1 é¡¹ï¼›å®žé™… `docs/公路旅客/模板_公路旅客运政车辆数.xlsx`、`docs/能耗/模板_能耗车辆运政信息.xlsx` éƒ½æœ‰ç‹¬ç«‹æ¨¡æ¿ä½†æ— æ³•å•ç‹¬å¯¼å…¥ï¼ˆåªèƒ½éšæœˆæŠ¥/季报第二个 sheet è‡ªåŠ¨è§£æžï¼‰ã€‚
**设计结论**：模块下拉 = è¯¥æ¨¡å—模板清单；运政类模板支持独立导入，同时保留「随主文件第二个 sheet è‡ªåŠ¨å¯¼å…¥ã€çš„兼容行为（后导入覆盖，幂等）。
**后端**（`DataImportService.java` + `DataImportController.java`）
- æ–°å¢ž `POST /api/import/passengerAuth`：解析 4 åˆ—（企业代码/企业名称/车辆数/载客位数）→ `passenger_auth_vehicle`，同报表期先删旧数据 + æ¸… H2031 å®¡æ ¸ç»“果（`deleteRuleResults` æ–°ç§æœ‰æ–¹æ³•ï¼‰ã€‚
- æ–°å¢ž `POST /api/import/energyAuth`：解析 5 åˆ—（车牌号/车辆类型/燃料类型/标记吨位/准牵引质量）→ `h204_auth_vehicle`，同报表期先删 + æ¸… H204 å®¡æ ¸ç»“果。
**前端**（`DataImport.vue`）
- å…¬è·¯æ—…客下拉加「运政车辆数」，能耗下拉加「能耗车辆运政信息」；TYPE_LABELS è¡¥æ–°ç±»åž‹ + å¤§å†™é”®ï¼ˆæœ€è¿‘导入记录 H2031/H204/PASSENGER_AUTH ç­‰æ˜¾ç¤ºå‹å¥½åï¼‰ï¼›typeDesc/templateName/endpoint åŒæ­¥è¡¥å……。
**验证**：后端 `mvn compile` é€šè¿‡ï¼›é‡å¯åŽ curl å®žæµ‹ï¼šæ—…客运政模板导入 767 æ¡ã€èƒ½è€—运政模板导入 1114 æ¡ï¼Œå‡æˆåŠŸï¼ˆæµ‹è¯•æœŸ 2099-01 å·²æ¸…理）；前端 frontend.log `Compiled successfully in 308ms`（10:55:35）。
**说明**：城市客运的轨道/轮渡/网约车模板属月报字段与拆分逻辑（需求文档确认），非独立导入类型，下拉保持 3 é¡¹ï¼›æŠ•èµ„模板按市州上报原始文件 + æ±‡æ€»å¤§è¡¨å¤„理，下拉保持 3 é¡¹ã€‚
**产物**：`_shots/patch_auth_import.py`（后端）、`_shots/patch_dataimport_options.py`（前端）、`_shots/compile_auth_import.log`。


### 2026-08-26 ä¸Šåˆä¼šè¯ï¼ˆç»­3）：数据导入页改版——待导入队列 + æœ¬æœˆå¯¼å…¥è¿›åº¦æ€»è§ˆï¼ˆå·²å®ŒæˆéªŒè¯ï¼‰
**用户反馈**：导入页五个模块下拉互斥（选一个清空其他），一次只能传一个文件，每月重复操作多；要一份"本月各模块导入状态"的检查清单。
**前端**（`DataImport.vue` æ•´ä½“重写，`_shots/rewrite_dataimport.py`）
- äº”个模块下拉互相独立（互斥逻辑删除），选类型后行内出现「选择文件 â†’ åŠ å…¥é˜Ÿåˆ—」；模板名/说明/大文件耗时提示跟随当前选中类型显示。
- æ–°å¢žã€Œå¾…导入队列」卡片：模块/类型/文件/状态（待导入/导入中/成功/失败）/结果（失败带原因）/操作（单条导入、移除），顶部「全部导入（N）」串行逐个执行，投资类型导入后自动触发投资系统校验弹窗。
- æ–°å¢žã€Œæœ¬æœˆå¯¼å…¥è¿›åº¦ã€å¡ç‰‡ï¼šæŒ‰æŠ¥è¡¨æœŸ Ã— æ¨¡å—类型展示 å·²å¯¼å…¥N行（绿）/部分失败（橙）/未导入（灰），随报表期切换自动刷新。
- ã€Œå¯¼å…¥è®°å½•ã€æ”¹ä¸ºæŒ‰å½“前报表期过滤显示（limit 50）；文案修正为"选择类型并挂载文件"。
**后端**（`DataImportController.java`）
- `/api/import/batches` å¢žåŠ å¯é€‰ `period` å‚数（limit ä¸Šé™æåˆ° 200），供进度总览按报表期拉取。
**验证**：后端 `mvn compile` é€šè¿‡ + start-dev.ps1 é‡å¯å°±ç»ªï¼›`GET /api/import/batches?period=2026-07` æ­£å¸¸è¿”回该期记录（货运量周转量/规上规下/轨迹/运政/巡游出租均已导入）；前端 frontend.log `Compiled successfully in 522ms`（11:01:41）。
**待办（用户可选的锦上添花）**：每个导入类型旁加「下载模板」链接（后端暴露 docs æ¨¡æ¿é™æ€æ–‡ä»¶ï¼‰ï¼Œç”¨æˆ·ä¸ç”¨åŽ»æ–‡ä»¶å¤¹æ‰¾æ¨¡æ¿ã€‚


### 2026-08-26 ä¸Šåˆä¼šè¯ï¼ˆç»­4）：数据导入页「下载模板」入口（已完成验证）
**实现**
- åŽç«¯ï¼š`application.yml` æ–°å¢ž `docs.template-root: docs`；新建 `TemplateDownloadController.java`（`com.trafficaudit.config`）：`GET /api/templates/{*path}` ä¸‹è½½ docs ä¸‹æ¨¡æ¿ï¼ŒContent-Disposition å¸¦ UTF-8 æ–‡ä»¶åï¼Œé˜²è·¯å¾„穿越；模板定位与报表模块一致（配置目录 â†’ user.dir â†’ user.dir/.. é€çº§å›žé€€ï¼Œå›  spring-boot:run çš„ user.dir æ˜¯ traffic-audit-server）。静态资源映射方案（WebConfig）因相对路径解析失败已弃用删除。
- å‰ç«¯ `DataImport.vue`：每个导入类型新增 `templateUrl`（docs ç›¸å¯¹è·¯å¾„），模板说明区显示「下载模板」链接；投资两模板指向 `docs/投资/输入/客运（客运站）/` ä¸Ž `docs/投资/输入/物流（物流园区）/` ä¸‹çš„更新明细文件；`passengerIndividual` æ— ç‹¬ç«‹æ¨¡æ¿æ–‡ä»¶ï¼Œä¸æ˜¾ç¤ºä¸‹è½½ã€‚
**验证**：14 ä¸ªæ¨¡æ¿ä¸‹è½½å…¨éƒ¨ 200（含中文路径与全角括号/逗号）；前端 frontend.log `Compiled successfully in 505ms`（11:10:10）。
**注意**：投资模板文件名带月份（更新_7月…），每月需同步更新 `DataImport.vue` çš„ templateUrl æˆ–改为动态映射。


### 2026-08-26 ä¸­åˆä¼šè¯ï¼šæ•°æ®å¯¼å…¥é¡µ tabs åŒ– + å…¨å±€æ¨¡å—顺序统一（已完成验证）
**用户反馈**：①数据导入界面模块太多、风格繁琐；②所有页面模块顺序应统一为「货运 â†’ å…¬è·¯æ—…客 â†’ åŸŽå¸‚客运 â†’ æŠ•èµ„ â†’ èƒ½è€—」（当前部分页面把投资/能耗排在前面）。
**前端改动（4 ä¸ª Vue æ–‡ä»¶ï¼‰**
- `DataImport.vue`：五个模块下拉并排改为 **el-tabs é€‰é¡¹å¡**（顺序：货运/公路旅客/城市客运/投资/能耗），选中类型后显示「选择文件 â†’ ç«‹å³å¯¼å…¥ / åŠ å…¥é˜Ÿåˆ—」；卡片头部加引导文案；`groups` é‡æŽ’为新顺序；`activeModule: 'freight'` åŠ å…¥ data。操作链不变：选类型→挂文件→立即导入/加入队列→全部导入。
- `AuditResult.vue`：报表类型 radio é¡ºåºæ”¹ä¸º è´§è¿H2032→旅客H2031→城市公交CITY_BUS→巡游出租CITY_TAXI→投资INVEST→能耗H204。
- `RuleManage.vue`：同上顺序。
- `ReportExport.vue`：`modules` é¡ºåºæ”¹ä¸º freight→passenger→cityPassenger→invest→energy，卡片 CSS `repeat(6,1fr)`，第1-3å¼  span2、第4-5å¼  span3（第一排 è´§è¿/旅客/城市客运，第二排 æŠ•èµ„/能耗）。
**验证（无头浏览器真实 DOM + æˆªå›¾ï¼‰**
- å‰ç«¯ frontend.log æœ€æ–° `Compiled successfully`（11:30:34），无编译错误。
- å¯¼å…¥é¡µ tabs = `["货运","公路旅客","城市客运","投资","能耗"]`，active=货运，按钮 = `["选择文件","立即导入","加入队列"]`，overviewGroups åŒé¡ºåºï¼Œ0 ä¸ª JS é”™è¯¯ï¼›æˆªå›¾ `_shots/import_page_tabs2.png`（人工确认清爽无异常）。
- ä¾§è¾¹æ åˆ‡é¡µéªŒè¯ï¼šå®¡æ ¸ç»“æžœ radio=货运/旅客/城市公交/巡游出租/投资/能耗 + æŒ‰æ¡æ˜Žç»†/按企业合并；规则管理 radio å‰6项同序；报表生成卡片=货运(H203-2)/公路旅客(H203-1)/城市客运/投资/能耗(H204)；截图 `_shots/order_check3.png`（卡片布局美观）。
- **路由切页坑**：`location.hash='#/audit'` ç›´æŽ¥èµ‹å€¼ä¸ç”Ÿæ•ˆï¼ˆè¢«é‡ç½®å›ž #/import），必须点击侧边栏 `.el-menu-item` åˆ‡é¡µã€‚
**产物**：`_shots/patch_module_order.py`、`_shots/patch_radio_order.py`、`_shots/patch_tab_clean.py`、`_shots/shot_import_tabs.js`、`_shots/shot_import_tabs2.js`、`_shots/order_check.js`、`_shots/order_check2.js`、`_shots/order_check3.js`。
**待办（可选锦上添花）**：若用户仍觉繁琐，可把「本月导入进度」与「选择类型挂载文件」两张卡合并成一张；导入类型旁「下载模板」链接已在续4落地。


### 2026-08-26 ä¸­åˆä¼šè¯ï¼šæŠ•èµ„ M2 å¸‚州单表批量导入（已完成验证）
**需求**：HANDOFF é—留「投资 M2（市州单表解析）未开工」→ å®žçŽ°æŒ‰å¸‚州单表目录批量导入客运站场/物流园区月度数据。
**实现**
- åŽç«¯ `DataImportService.importInvestCityDir(period, category)` + `POST /api/import/investCityBatch`（period=yyyy-MM，category=客运站场|物流园区）：扫描 `docs/投资/输入/{类别目录}/{N月}` ä¸‹å…¨éƒ¨ xls/xlsx/et（跳过 pdf，N月由 period æŽ¨å¯¼ï¼‰ï¼Œå®¹é”™è§£æžæ¯ä¸ªæ–‡ä»¶ï¼ˆå®šä½è¡¨å¤´è¡Œ + åˆ—名关键词映射 + åŒå±‚表头合并 + å¸‚州小节行识别），逐文件返回行数/失败行号，幂等（同类别同报表期月度+INVEST å®¡æ ¸å…ˆåˆ ï¼Œé¡¹ç›®ä¸»æ¡£æŒ‰ã€Œé¡¹ç›®å+类别」upsert）；与「模板_十五五规划物流项目进展情况.xls」规范化匹配标记 is_five_year。
- å‰ç«¯ `DataImport.vue` æŠ•èµ„ tab æ–°å¢žã€Œå¸‚州单表批量导入（客运站场/物流园区）」类型 +「从目录批量导入」按钮 + é€æ–‡ä»¶ç»“果弹窗。
- æ–‡ä»¶è¯»å–：只读文件必须 `new FileInputStream(f)` åŒ…一层（直接 `WorkbookFactory.create(File)` æŠ›ã€Œæ‹’绝访问」）。
**DB çŽ°çŠ¶ï¼ˆmysql 3308 / traffic_audit）**
- investment_project：客运站场 46、物流园区 132（已清 2 ä¸ªå­¤å„¿æ®‹ç•™ï¼‰ï¼›å…¨éƒ¨ total_investment>0。
- investment_monthly：客运 6月35/7月46、物流 6月132/7月133（共 346），0 å¤±è´¥ï¼›2026-07 åäº”五项目 35 ä¸ªã€‚
- å¯¼å‡º `GET /api/report/export/investFiveYearLogistics?period=2026-07` åˆè®¡ï¼šæ€»æŠ•èµ„ 2038714.59 / è‡ªå¼€å§‹ç´¯è®¡ 691375.3 / è‡ªå¹´åˆç´¯è®¡ 246779.55，与 DB èšåˆé€åˆ†ä¸€è‡´ï¼ˆprobe：`_shots/verify_export_m2/report_v2.txt`）。
**本轮新踩坑（务必记住）**
1. ã€Œæ€»æŠ•èµ„」vs「计划总投资」：武汉等表头是「总投资」；宜昌/襄阳等是「计划   æ€»æŠ•èµ„（万元）」（中间有空格）→ åˆ—映射必须 `contains("计划总投资")||contains("总投资")` ä¸”排除「累计」，否则 total=0。
2. **公式单元格**：.et（WPS è·¨è¡¨å…¬å¼ `='2026å¹´6月 '!I12+L12`）`DataFormatter.formatCellValue` æ—  evaluator æ—¶åªè¿”回公式文本→解析 0。修复：`getDecimal/getDecimalOrNull/getString` å¯¹ FORMULA å•å…ƒæ ¼è¯» `getCachedFormulaResultType()`/`getNumericCellValue()`。
3. **多 sheet åŽ†å²æ–‡ä»¶é€‰æœŸ**：襄阳 .et å« 1-7 æœˆ 12 ä¸ª sheet，原逻辑「选 countInvestRows æœ€å¤šã€ä¼šé”™é€‰ 2月 sheet（首个 6 è¡Œï¼‰ï¼Œ7月数据错存 2月值。修复：`investSheetMatchesPeriod` æŒ‰ sheet åå«ã€ŒN月/0N月/period」优先（数据行>0 æ—¶ +1000000 åˆ†ï¼‰ã€‚
4. é¡¹ç›®åå«æ¢è¡Œï¼ˆ`咸宁高新区冻库冷链项目
（一期）`）：`replaceAll("[\r\n]+","")`；修复前残留的孤儿项目（黑豹国际物流园/咸宁冻库）已从 investment_project åˆ é™¤ï¼ˆæ— æœˆåº¦å¼•ç”¨ï¼‰ã€‚
5. æ—  seq åˆ—（随州 Sheet2）：有 seq æŒ‰åºå·åˆ¤å®šã€æ—  seq ç”¨ `investmentCity(nt)` è¯†åˆ«å¸‚州行。
6. ã€Œå¡«æŠ¥å•ä½ã€å¸‚州提取必须 contains åŒ¹é…ï¼ˆ"武汉市交通运输局客运事业发展中心"）。
7. æ½œæ±Ÿ/林区文件解析 1 æ¡ï¼ˆæ½œæ±Ÿä¼ åŒ–公路港）是正确的；多 sheet é€‰æœŸä¿®å¤ä¸å½±å“å…¶ç»“论。
**十五五 28 ä¸ªç¼ºé¡¹ç›®ï¼ˆçœŸå®žç¼ºå£ï¼‰**
- æ¨¡æ¿ 63 é¡¹ï¼Œè§„范化匹配 35 è¦†ç›– / ç¼º 28（数据源不在市州单表）：清单见 `_shots/five_year_report.txt`，需用户提供数据或确认口径。
**产物**：`_shots/insert_m2.py`（M2 ä»£ç æ’入）、`_shots/fix_*.py`（各 bug ä¿®å¤ï¼‰ã€`_shots/fix_formula_cached.py`、`_shots/fix_sheet_period.py`、`_shots/m2_compile*.log`、`_shots/ProbeEt*.java`（POI å…¬å¼/多 sheet æŽ¢æµ‹ï¼‰ã€`_shots/verify_export_m2/`（十五五导出复验）、`_shots/five_year_report.txt`、`_shots/verify_m2.js` + `_shots/m2_batch_dialog.png`（前端弹窗验证）。
**待办**：①28 ä¸ªåäº”五项目缺口等用户提供数据源；②能耗新 6 æ¡è§„则阈值口径待确认；③货运《模板_货运量周转量》《规上规下拆分表》未导入；④7-12 æœˆæ¨¡æ¿å¾…用户提供；⑤可选「本月导入进度」与「挂载文件」两卡合并。


### 2026-08-26 åˆåŽä¼šè¯ï¼šæŠ¥è¡¨ç”Ÿæˆ P0 ä¸‰é¡¹ + æ¨¡æ¿æ•°æ®è§„则梳理（已完成验证）
**背景**：用户问「报表生成模块怎么看」→ ç»™å‡ºè¯„估（模板底稿生成是亮点；数据完备性不可见/错误信息被吞/文件名不一致/单文件过大/月报语义易误读），用户同意先做 P0 ä¸‰é¡¹ã€‚
**P0-1 æ•°æ®å°±ç»ªæ ¡éªŒ**
- åŽç«¯ `ReportExportService.checkExportReady(period, mode, types)` + `GET /api/report/ready`：按报表类型统计依赖表行数（month ç²¾ç¡®åŒ¹é… report_period、year ç”¨ likeRight å¹´ä»½å‰ç¼€ï¼‰ï¼š
  - è´§è¿ä¸‰è¡¨ â†’ æ¨¡æ¿_货运量周转量(freight_turnover_import) + è§„上规下拆分表(scale_split_transport) + H203-2 æœˆæŠ¥(h2032_enterprise_monthly)
  - æ—…客四表 â†’ H203-1 æœˆæŠ¥(h2031_enterprise_monthly) + ä¸ªä½“(passenger_individual_monthly)
  - cityBus/cityRailFerry â†’ city_bus_monthly；cityTaxi â†’ city_taxi_monthly；城市客运汇总三表 â†’ å…¬äº¤+出租
  - æŠ•èµ„四表 â†’ investment_monthly；能耗 â†’ h204_vehicle_quarterly
- å‰ç«¯ `exportChecked` å…ˆè°ƒ ready：有缺数据表 â†’ `$confirm`「数据未就绪」列出缺哪些（如「城市公交客运量分市州明细（缺数据：城市公交月报）」），可「仍要导出/取消」；无缺 â†’ ç›´æŽ¥å¯¼å‡ºã€‚
**P0-2 é”™è¯¯é€å‡º**
- æ–°å¢ž `GlobalExceptionHandler`（com.trafficaudit.common）：Exception â†’ HTTP 500 + `Result.error(500, message)`（log.error å…¨é‡å †æ ˆï¼‰ï¼›å‰ç«¯ `failWith(err)` è¯» `err.response.data.message` æ˜¾ç¤ºå…·ä½“原因。
- éªŒè¯ï¼š`curl /api/report/export/energySummary?period=2026-99` â†’ `{"code":500,"message":"32",...}` é“¾è·¯é€šã€‚
**P0-3 æ–‡ä»¶åç»Ÿä¸€ + MIME**
- å‰ç«¯æ—…客 4 ä¸ª fileName å¯¹é½åŽç«¯å…¨åï¼ˆå…¬è·¯æ—…客分市州明细/中口径明细/中口径排名/中口径分析）；`buildResponse` æŒ‰ .xls ç”¨ `application/vnd.ms-excel`、.xlsx ç”¨ ooxml。
**顺手修复**：`ReportExport.vue` data ç¼º `activeMenu: '/report'`（此前侧边栏当前页不高亮 + Vue warn）。
**验证**：ready å„表数值与 DB é€è¡¨æ ¸å¯¹ä¸€è‡´ï¼ˆcityDetail=690、passenger=771+缺个体、cityTaxi=17、invest=179、energy=126、cityBus=0 å‡†ç¡®åæ˜ å…¬äº¤æœˆæŠ¥æœªå¯¼å…¥ï¼‰ï¼›æ— å¤´æµè§ˆå™¨ï¼ˆ`_shots/report_ready_dialog.js`）：case1 ç¼ºæ•°æ®å¼¹ã€Œæ•°æ®æœªå°±ç»ªã€ç¡®è®¤æ¡†å†…容正确、case2 æ•°æ®é½å…¨ç›´æŽ¥ä¸‹è½½+「报表导出成功」；JS 0 é”™è¯¯ï¼›å‰ç«¯ 12:55:10 Compiled successfully。
**模板数据规则（用户新确认的需求方向，待口径确认）**：模板即权威，系统严格按模板三类规则填数——A å¡«æ”¾è§„则（数据区行/列/合并对号入座）、B è®¡ç®—规则（模板已有公式如能耗折算系数 D3=C3/B3、M3=K3/I3*100*0.86*1.4571、城市汇总合计 P3=P4+P5+P8+P9、同比 L14=H14/M14-1 ç­‰ â†’ ä¿ç•™å…¬å¼åªå¡«åŽŸå§‹é‡ï¼›æ¨¡æ¿æ— å…¬å¼å¦‚货运_货运量周转量 â†’ ç³»ç»ŸæŒ‰å£å¾„算好填入）、C æ ¼å¼è§„则（列宽/表头/合并/单位完全一致）。**待用户确认**：①公式类模板保留公式 vs ç³»ç»Ÿå†™æ­»ç®—好的值；②数据行数超模板预留行数时是否动态插行并同步公式；③「数据规则」是否还包括单位换算/审核后填数/月报 1~N æœˆå£å¾„。

### 2026-08-26 ä¸‹åˆç»­ï¼šå®¡æ ¸æ ‡è®°è¡¨ï¼ˆaudit_run）落地，历史已审核数据不再误报「未审核」（已完成验证）
**用户口径（关键）**：现有数据（7 æœˆåŠä»¥å‰ï¼‰éƒ½æ˜¯çº¿ä¸‹å®¡æ ¸é€šè¿‡çš„、可直接导出，不应提示未审核；只有 **8 æœˆæ•°æ®æœªå®¡æ ¸**。之前用 `audit_result` é—®é¢˜æ¡æ•°åˆ¤æ–­ audited æ˜¯é”™çš„——审核全通过时 0 æ¡ä¼šè¯¯åˆ¤ä¸ºæœªå®¡æ ¸ã€‚
**方案**：新增 `audit_run` æ ‡è®°è¡¨ï¼ˆreport_type + report_period å”¯ä¸€ï¼‰ï¼Œã€Œå·²å®¡æ ¸ã€ä»¥è¯¥è¡¨ä¸ºå‡†ï¼›å¯¼å‡ºå‰ ready æ ¡éªŒæŸ¥ audit_run，不再依赖 audit_result è¡Œæ•°ï¼ˆauditRows ä¿ç•™ä¸ºä¿¡æ¯å­—段）。
**后端（已编译重启验证）**
- å»ºè¡¨ `audit_run`（id/report_type/report_period/created_at，uk_type_period，utf8mb4），MySQL 3308 traffic_audit。
- æ–°å¢ž `AuditRun` å®žä½“ + `AuditRunMapper`（BaseMapper）。
- `AuditEngineService`：4 å‚æ•° `markAudited(reportType, period, rules, hasData)`（幂等，无规则/无数据不写）+ æ–°å¢ž 2 å‚数重载 `boolean markAudited(reportType, period)`——内部按类型取启用规则（rulesOf）+ æŒ‰ç±»åž‹æŸ¥æ•°æ®è¡¨ï¼ˆH2032→h2032、H2031→passenger、H204→energy、INVEST→investMonthly、CITY_BUS→cityBus、CITY_TAXI→cityTaxi）再写标记；6 ä¸ª execute æ–¹æ³•æœ«å°¾å·²è°ƒ 2 å‚数版（执行审核后自动写标记）。
- `AuditController`：`POST /api/audit/markAudited?period=&reportType=` è¿”回 `Result<Boolean>`（是否写入标记）。
- `ReportExportService.checkExportReady`：`audited` æ”¹ä¸ºé€ auditType æŸ¥ `audit_run`（month=eq ç²¾ç¡® / year=likeRight），任一类型有标记即 audited=true；注入 `AuditRunMapper`。
**前端（热更新已生效，Compiled successfully）**
- `AuditResult.vue`：「执行审核」旁新增「标记已审核」按钮（调 markAudited，成功提示/无规则无数据提示并刷新列表）。
- `ReportExport.vue` æ— éœ€æ”¹ï¼š`unaudited = ready && audited===false` é€»è¾‘已与 audit_run è¯­ä¹‰å»åˆã€‚
**历史数据补标（audit_run å·²å†™å…¥ 6 æ¡ï¼‰**：H2031 07、H2032 07、H204 07、INVEST 06+07、CITY_TAXI 07；**H2032 08 æœªæ ‡**（8 æœˆæœªå®¡æ ¸ï¼‰ï¼›CITY_BUS æ— æ•°æ®ä¸æ ‡ã€‚
**验证（全部通过）**
- `GET /api/report/ready?period=2026-07&mode=month&types=cityDetail,passengerCityDetail,cityTaxiDetail,investPlan,energySummary` â†’ å…¨éƒ¨ audited=true（passengerCityDetail auditRows=0 ä½† audited=true，正是修复点）。
- `period=2026-08` â†’ cityDetail rows=142（H2032 8 æœˆæœ‰æ•°æ®ï¼‰audited=false，其余无数据 ready=false。
- `POST /api/audit/markAudited`：H2032/2026-07 â†’ true（幂等）；CITY_BUS/2026-07 â†’ false（无数据不标记）。
- åŽç«¯ start-dev.ps1 é‡å¯ OK（Started + 8090）；前端 14:32:12 Compiled。
**产物**：`_shots/compile_auditrun.log`、`%TEMP%\patch_*.py`（audit_2arg / audit_controller2 / report_audited / auditresult_vue2）、`%TEMP%\db_mark_history.py`。
**遗留/待办不变**：投资 M2 æœªå¼€å·¥ï¼›7-12 æœˆæ¨¡æ¿å¾…提供；货运《模板_货运量周转量》《规上规下拆分表》未导入；能耗新规则阈值待确认。

### 2026-08-26 ä¸‹åˆç»­2：登录接通 + ç”¨æˆ·ç®¡ç†ï¼ˆè´Ÿè´£æ¨¡å—勾选）+ æŠ¥è¡¨ç”Ÿæˆé¡µè½¯éš”离（已完成验证）
**需求（用户确认）**：报表生成页按「三人分工」做软隔离（货运1人、旅客+投资+能耗1人、城市客运1人）——登录后默认只看自己负责的模块、可切换「查看全部模块」；模块归属在**用户上勾选**（更灵活）。
**现状发现**：登录原为假登录（Login.vue ç›´æŽ¥è·³è½¬ä¸æ ¡éªŒï¼‰ã€UserManage.vue ä¸ºå ä½é¡µã€sys_user/sys_role è¡¨ä¸ºç©º â†’ æœ¬æ¬¡ä¸€å¹¶è¡¥é½é“¾è·¯ã€‚
**数据库**：`sys_user` åŠ  `modules` å­—段（逗号分隔：freight,passenger,invest,energy,cityPassenger）；初始化 4 ä¸ªè´¦å·ï¼ˆå¯†ç å‡ 123456，BCrypt ç”± spring-security-crypto ç”Ÿæˆï¼‰ï¼š
- admin/管理员（5 æ¨¡å—全选）、zhangsan/张三（freight）、lisi/李四（passenger,invest,energy）、wangwu/王五（cityPassenger）。
**后端（已编译重启）**
- `User` å®žä½“加 modules；新增 `UserController`（/api/user/list å…³é”®å­—搜索、/save æ–°å¢žç¼–辑=密码留空不改+BCrypt、/delete ç¦æ­¢åˆ  admin）；`LoginController` ç™»å½•è¿”回 token+username+realName+modules（错误 401）。
**前端（热更新已生效，Compiled successfully 15:20:43）**
- `Login.vue` è°ƒ /api/auth/login，存 token/username/realName/modules；`router/index.js` åŠ ç™»å½•å®ˆå«ï¼ˆæ—  token è®¿é—®ä¸šåŠ¡é¡µè·³ /login）；`main.js` å…¨å±€ mixin logout（清 localStorage å›žç™»å½•é¡µï¼‰ï¼Œ8 ä¸ªä¸šåŠ¡é¡µä¾§è¾¹æ ç»Ÿä¸€åŠ ã€Œé€€å‡ºç™»å½•ã€èœå•é¡¹ã€‚
- `UserManage.vue` é‡å†™ï¼šç”¨æˆ·åˆ—表（用户名/姓名/手机号/负责模块 tags/状态/创建时间/编辑删除）+ æ–°å¢žç¼–辑弹窗（含「负责模块」el-checkbox-group 5 é¡¹ + çŠ¶æ€ï¼‰ã€‚
- `ReportExport.vue` è½¯éš”离：顶部 focus-bar æ˜¾ç¤ºã€Œå½“前用户/负责模块」+ ã€ŒæŸ¥çœ‹å…¨éƒ¨æ¨¡å—」el-switch；`visibleModules` computed é»˜è®¤è¿‡æ»¤è‡ªå·±çš„模块（未配置或过滤为空则显示全部）。
**验证（全部通过）**
- ç™»å½•ï¼šadmin è¿”回 5 æ¨¡å—、zhangsan è¿”回 freight、错误密码 401；用户 CRUD：新增/重名 400/编辑改模块/删除，测试账号已清理，最终 4 ç”¨æˆ·ã€‚
- æ— å¤´æµè§ˆå™¨ e2e（`_shots/usermgr_e2e.js/png`）：未登录访问 #/report â†’ è·³ #/login；zhangsan ç™»å½• â†’ /report åªæ˜¾ç¤ºè´§è¿å¡ï¼ˆfocus-bar：当前用户：张三 è´Ÿè´£æ¨¡å—：货运报表（H203-2）），点开关 â†’ 5 å¼ å¡å…¨æ˜¾ç¤ºï¼›admin ç™»å½• â†’ /users è¡¨æ ¼ 4 è¡Œï¼›JS 0 é”™è¯¯ã€‚
**产物**：`_shots/usermgr_e2e.js/png`、`_shots/compile_usermgr.log`、`%TEMP%\db_init_users.py`（初始化账号 SQL，可复用）。
**遗留/待办不变**：投资 M2 æœªå¼€å·¥ï¼›7-12 æœˆæ¨¡æ¿å¾…提供；货运《模板_货运量周转量》《规上规下拆分表》未导入；能耗新规则阈值待确认。报表页「状态可视化（数据就绪/已审核状态条）」与「最近生成记录」仍在待办讨论列表。

### 2026-08-26 æ™šé—´ç»­5：报表模板自动向右扩列（1-6月 â†’ 1-12月）+ æŠ¥è¡¨ç”Ÿæˆé¡µå•æ¨¡å—工作台（已完成验证）
**需求（用户确认）**：①按当前想法先出一版看效果（单模块工作台界面）；②月度模板**自动向右扩展列**：复制列头/公式/样式并同步公式引用，扩列格式与规则按 1-6 æœˆæ—¢æœ‰è§„则举一反三，无需逐月人工确认。
**后端扩列（已编译重启 + HTTP å¯¼å‡ºéªŒè¯é€šè¿‡ï¼‰**
- ä¸‰å¼ æŠ¥è¡¨å¯ç”¨æ‰©åˆ—：`exportCityDetail`（货运分市州）、`exportPassengerCityDetail`（公路旅客分市州）、`exportPassengerMidDetail`（中口径明细）。`fillMonths = Math.min(currentMonth,6)` æ”¹ä¸º `currentMonth`；`fillMonths > 6` æ—¶è°ƒç”¨ `extendMonthlyColumns(sheet, headerRow, year, dataStart, dataEnd)`。
- æ‰©åˆ—逻辑：累计列对从 14/15 åˆ—移到 26/27 åˆ—（AB）；7-12 æœˆåˆ—对由 1 æœˆåˆ—对克隆（表头文本/日期修正、样式复制、非跨簿公式克隆且列引用同步平移，正则 `shiftMonthFormula`）；累计列公式重写为 12 ä¸ªæœˆå€¼ä¹‹å’Œï¼ˆ`fixCumulativeFormulas`，公式不带 `=` å‰ç¼€ï¼ŒPOI `setCellFormula` ä¸æŽ¥å— `=` å¼€å¤´â€”—已踩坑修复）。
- åŒæ¯”列：原 #REF! å…¬å¼è¦†å†™ä¸º Java åº“内计算值。货运调 `getCityMonthYoy`/`getProvinceMonthYoy`；旅客新增 `passengerCumYoy`/`passengerMonthVal` + ç´¯è®¡åŒæ¯”覆写；中口径新增 `fillMidYoyCell`/`fillMidCumYoyColumn`。循环起点 r=4 â†’ r=3（R4 æ˜¯å…¨çœåŒºåŸŸæ ‡è®°è¡Œï¼ŒA4:A7 åˆå¹¶ï¼‰ï¼Œæ—…客 #REF! æ¸…零。
- å·²çŸ¥å£å¾„（沿用现状，未改）：模板表头为「1月与去年同比」，7-12 æœˆåŒæ¯”列沿用 1-6 æœˆåˆ—做法，即「去年同月 vs ä»Šå¹´åŒæœˆã€çš„同比数值（`yearYoy`）。若后续要求改为「环比上月」需另改。
- **数据源缺口（非代码问题，需用户补数据）**：①`freight_turnover_import` 2026-07 çš„当月字段（freight_m07/turnover_m07）为 NULL，只有去年同月 â†’ 7 æœˆåˆ—只有 H2032 è§„上货运量 + æ‹†åˆ†è¡¨å‘¨è½¬é‡ï¼Œå…¨çœåˆè®¡/规下货运量 7 æœˆä¸ºç©ºï¼ˆé¢„览弹窗「缺月数据：7月」与此一致）；②`h2031_enterprise_monthly` åªæœ‰ 2026-07（771 è¡Œï¼‰ï¼Œ1-6 æœˆä¸Ž 2025 å¹´å‡ä¸ºç©º â†’ æ—…客表 1-6 æœˆåˆ—空、累计同比（AB åˆ—）空；③8-12 æœˆåˆ—数据依赖后续月份数据源。
- HTTP å¯¼å‡ºéªŒè¯ï¼ˆ2026-07 æœˆæŠ¥ï¼‰ï¼šcityDetail A1:AB112、passengerCityDetail A1:AB58、passengerMidDetail A1:AB94；表头 1-12 æœˆ + ç´¯è®¡ + åŒæ¯”正确；#REF! å…¨éƒ¨æ¸…零；累计列公式 =C+E+G+…+Y（12 ä¸ªæœˆå€¼åˆ—之和）；合并单元格同步。
**前端：ReportExport.vue é‡å†™ä¸ºå•æ¨¡å—工作台（热更新已生效，无编译错误）**
- å·¦ä¾§ 240px æ¨¡å—导航（模块名 + å¼ æ•° + å½“前报表期），右侧单模块面板：顶部报表方式/报表期，中间报表表格（勾选 + æŠ¥è¡¨å + æ•°æ®çŠ¶æ€æ ‡ç­¾ã€Œæ•°æ®å°±ç»ª/未审核/缺数据」+ å¤‡æ³¨ + é¢„览/导出），底部全选 +「预览选中/导出选中（zip）」。
- é»˜è®¤èšç„¦å½“前用户负责模块（登录时按用户 modules è¿‡æ»¤ï¼‰ï¼Œé¡¶éƒ¨ã€ŒæŸ¥çœ‹å…¨éƒ¨æ¨¡å—」开关可切换全部 5 æ¨¡å—；保留 `/report/ready` çŠ¶æ€åˆ·æ–°ã€`/report/preview` é¢„览弹窗、`/report/export/{key}` å•å¼ å¯¼å‡ºã€`/report/export/selected` zip å¤šå¼ å¯¼å‡ºã€‚
- æ— å¤´æµè§ˆå™¨ e2e（`_shots/report_workbench_e2e2.js`）：张三登录 â†’ åªæ˜¾ç¤ºè´§è¿æ¨¡å—（navCount=1）；开「查看全部模块」→ 5 æ¨¡å—全显；货运 2026-07 ä¸‰å¼ æŠ¥è¡¨çŠ¶æ€å‡ã€Œæ•°æ®å°±ç»ªã€ï¼›é¢„览弹窗标题「预览数据 - è´§è¿æŠ¥è¡¨ï¼ˆH203-2）（2026-07）」+ æ±‡æ€»/覆盖/缺月提示正确；JS 0 é”™è¯¯ã€‚截图 `_shots/report_workbench*.png`；HTTP å¯¼å‡ºæ ·å¼  `_shots/dl/*.xlsx`。
**验证命令/产物**：`GET /api/report/export/{key}?period=2026-07&mode=month`（三种 key å‡ 200）；`_verify_http_export*.py`、`_verify_expand*.py`、`_test_expand_*.xlsx`。
**遗留/待办不变**：投资 M2 æœªå¼€å·¥ï¼›è´§è¿ã€Šæ¨¡æ¿_货运量周转量》汇总表 7 æœˆæ•°æ®æœªå¯¼å…¥ï¼ˆå½±å“åˆè®¡/规下 7 æœˆåˆ—）；旅客 2025 å¹´åŒæœŸæ•°æ®ç¼ºå¤±ï¼ˆç´¯è®¡åŒæ¯”空）；8-12 æœˆåˆ—数据依赖数据源；能耗新规则阈值待确认。

### 2026-08-26 æ™šé—´ç»­6：报表生成页「报表方式/报表期」改为下拉框（已完成验证）
**需求（用户确认）**：界面上可选项改为下拉框选择方式。
**改动（ReportExport.vue）**
- ã€ŒæŠ¥è¡¨æ–¹å¼ã€ç”± el-radio-group æ”¹ä¸º el-select（月报/年报）；切换方式时自动清空报表期（新增 `onModeChange`）。
- ã€ŒæŠ¥è¡¨æœŸã€ç”± el-date-picker æ”¹ä¸º el-select åˆ†ç»„下拉（新增 `periodGroups`）：年报列出 2025/2026/2027 å¹´ï¼›æœˆæŠ¥æŒ‰å¹´åˆ†ç»„列出 1-12 æœˆï¼›èƒ½è€—模块（季度报）只列季度末月 3/6/9/12，分组标题标注「（季度末月）」。
- æ— å¤´æµè§ˆå™¨ e2e（`_shots/report_dropdowns_e2e.js`）：月报↔年报切换、年份/月份分组下拉、选 2026-07 åŽçŠ¶æ€åˆ·æ–°ã€Œæ•°æ®å°±ç»ªã€ã€JS 0 é”™è¯¯ã€‚截图 `_shots/report_dropdowns.png`。
**遗留/待办不变**：见晚间续5（数据源缺口等）。

### 2026-08-26 æ™šé—´ç»­7：报表类型改为下拉框（已完成验证）
**需求（用户澄清）**：上次改的是「报表方式/报表期」下拉框，用户实际指的是「选择报表的类型」也要用下拉框。
**改动（ReportExport.vue）**
- åˆ é™¤å·¦ä¾§ 240px æ¨¡å—导航栏（module-nav）与「查看全部模块」开关（showAllModules åŠ visibleModules è®¡ç®—属性一并移除）。
- é¢æ¿å¤´éƒ¨æ”¹ä¸ºã€ŒæŠ¥è¡¨ç±»åž‹ã€el-select：列出全部 5 ä¸ªæ¨¡å—（货运/公路旅客/城市客运/投资/能耗），默认仍聚焦当前用户负责模块（张三→货运），可在下拉框自由切换其他模块（软隔离 + çµæ´»å…¼é¡¾ï¼‰ã€‚
- æŠ¥è¡¨æ–¹å¼ã€æŠ¥è¡¨æœŸä¸‹æ‹‰æ¡†ä¿æŒä¸å˜ï¼›èƒ½è€—模块报表期仍只列季度末月 3/6/9/12。
- æ¸…理：selectModule→onModuleChange、删除 periodText、删除 module-nav ç›¸å…³ CSS。
**验证（无头浏览器 `_shots/report_type_dropdown_e2e.js`）**
- æ— ç¼–译错误、JS 0 é”™è¯¯ï¼›æŠ¥è¡¨ç±»åž‹ä¸‹æ‹‰ 5 ä¸ªé€‰é¡¹é½å…¨ï¼›é»˜è®¤å€¼ã€Œè´§è¿æŠ¥è¡¨ï¼ˆH203-2）」；切投资→4 å¼ æŠ¥è¡¨ã€åˆ‡èƒ½è€—→1 å¼ ï¼ˆèƒ½è¿æ±‡æ€»è¡¨ï¼‰ï¼›èƒ½è€—报表期仅季度末月；切回货运正常。截图 `_shots/report_type_dropdown.png`。
**遗留/待办不变**：见晚间续5（货运 7 æœˆæ±‡æ€»è¡¨æœªå¯¼å…¥ã€æ—…客 1-6 æœˆ/2025 åŒæœŸç¼ºå¤±ã€8-12 æœˆæ•°æ®ä¾èµ–数据源）。

 docs/³ÇÊпÍÔË/³ÇÊпÍÔËÊý¾ÝÓÅ»¯.docx

Binary files differ

 docs/³ÇÊпÍÔË/¿ÍÔ˼ò»¯.xlsx

Binary files differ

 docs/³ÇÊпÍÔË/¿ÍÔËÁ¿µÄͬ±È»·±ÈÊÇ0% ÐèºËʵ£¨Ö÷Òª³öÏÖÔÚ¹«½»£©.txt

 docs/³ÇÊпÍÔË/µ¼ÈëÄ£°å_³ÇÊй«½».xlsx

Binary files differ

 docs/³ÇÊпÍÔË/µ¼ÈëÄ£°å_³ÇÊзÖÊÐÖÝ.xlsx

Binary files differ

 docs/³ÇÊпÍÔË/µ¼ÈëÄ£°å_³ÇÊпÍÔ˸÷ÊÐÖÝÃ÷ϸ±í.xlsx

Binary files differ

 docs/³ÇÊпÍÔË/µ¼ÈëÄ£°å_³ÇÊлã×Ü.xlsx

Binary files differ

 docs/³ÇÊпÍÔË/µ¼ÈëÄ£°å_ѲÓγö×â.xlsx

Binary files differ

 docs/³ÇÊпÍÔË/µ¼ÈëÄ£°å_¹ìµÀ¡¢ÂÖ¶É.xlsx

Binary files differ

 docs/³ÇÊпÍÔË/Ä£°å_½»ÆóͳU203±í_³ÇÊй«¹²½»Í¨Ô¶ÈÔËÓªÇé¿ö£¨2026Äê7Ô£©.xls

Binary files differ

 docs/³ÇÊпÍÔË/Ä£°å_½»ÐÐͳU402±í-ѲÓγö×âÆû³µÔËÓª·þÎñÇé¿öÔ±¨(2026).xls

Binary files differ

 docs/³ÇÊпÍÔË/Éú³É_³ÇÊй«½»¿ÍÔËÁ¿·ÖÊÐÖÝÃ÷ϸ.xlsx

Binary files differ

 docs/³ÇÊпÍÔË/Éú³É_³ÇÊпÍÔ˸÷ÊÐÖÝÃ÷ϸ±í.xlsx

Binary files differ

 docs/³ÇÊпÍÔË/Éú³É_³ÇÊпÍÔË¿ÍÔËÁ¿·ÖÊÐÖÝÀÛ¼Æ.xlsx

Binary files differ

 docs/³ÇÊпÍÔË/Éú³É_³ÇÊпÍÔË»ã×Ü.xlsx

Binary files differ

 docs/³ÇÊпÍÔË/Éú³É_ѲÓγö×â¿ÍÔËÁ¿·ÖÊÐÖÝÃ÷ϸ.xlsx

Binary files differ

 docs/³ÇÊпÍÔË/Éú³É_¹ìµÀÂֶɿÍÔËÁ¿·ÖÊÐÖÝÃ÷ϸ.xlsx

Binary files differ

 docs/¿ªÔ´ÏîÄ¿¶Ô±È.md

New file
@@ -0,0 +1,90 @@
# åŒç±»å¼€æºé¡¹ç›®è°ƒç ”与对比（2026-08-23）

> æ£€ç´¢èŒƒå›´ï¼šGitHub Search API（中英文多关键词）、Gitee API（未认证不可用，已跳过）、知名项目 README æ ¸å®žã€‚
> æ£€ç´¢æ—¥æœŸï¼š2026-08-23

## ä¸€ã€ç»“论先行

**未发现与本项目直接同类的开源项目**（交通统计报表审核 + ä¸‰å‘˜æƒé™ + Excel å¯¼å…¥å®¡æ ¸ + æŠ¥è¡¨ç”Ÿæˆ + AI è§£é‡Šï¼Œè¿™æ¡ç»„合在 GitHub/Gitee å‡æ— çŽ°æˆå®žçŽ°ï¼‰ã€‚

原因：
1. è¿™ç±»ç³»ç»Ÿå¼ºç»‘定各省/各行业统计调查制度，业务口径无法通用化；
2. æ”¿åŠ¡é¡¹ç›®é€šå¸¸ç§æœ‰åŒ–交付，很少开源；
3. æ ¸å¿ƒä»·å€¼åœ¨å®¡æ ¸è§„则与业务口径，不在通用功能。

因此**自研方向正确，不需要纠结"选型/抄现成"**；但可以从四类"能力组件型"开源项目吸收设计思路。

## äºŒã€å‚照项目对比

### A. æ”¿åºœç»Ÿè®¡æŠ¥è¡¨ç”Ÿæˆï¼ˆæœ€æŽ¥è¿‘的直接同类）
**NIC Chennai â€“ Monthly Statistical Report Generation**
- å®šä½ï¼šå°åº¦å›½å®¶ä¿¡æ¯ä¸­å¿ƒï¼ˆNIC）实习生项目，自动化生成政府采购月度统计报表（MSR）
- æŠ€æœ¯æ ˆï¼šSpring Boot + Vue.js + PostgreSQL + Apache POI
- åŠŸèƒ½ï¼šå¤šæ•°æ®åº“动态连接（管理端配置）、按财年/月份生成报表、Excel æ ·å¼åŒ–输出（合并单元格/分组/合计）、Web ä¸‹è½½
- ä¸Žæœ¬é¡¹ç›®å¯¹æ¯”：
  - ç›¸ä¼¼ï¼šSpring Boot + Vue、Excel æŠ¥è¡¨è¾“出、按月生成统计报表
  - å·®è·ï¼ˆæˆ‘们更强）：无导入解析、无审核规则引擎、无三员权限、无 AI、单报表场景
- å¯å€Ÿé‰´ï¼šå¤šæ•°æ®æºè¿žæŽ¥ç®¡ç†ç•Œé¢ï¼ˆåŠ¨æ€é…ç½®æ•°æ®æºï¼‰â€”—投资模块对接"投资系统"时可参考

### B. å¿«é€Ÿå¼€å‘平台（国内政务底座）
**RuoYi-Vue（若依）**
- å®šä½ï¼šå›½å†…最主流的 Java å‰åŽç«¯åˆ†ç¦»å¿«é€Ÿå¼€å‘平台，大量政务系统基于它
- æŠ€æœ¯æ ˆï¼šSpring Boot（2/3/4 å¤šåˆ†æ”¯ï¼‰+ Spring Security + JWT + Redis + Vue2/3 + Element UI/Plus
- åŠŸèƒ½ï¼šä»£ç ç”Ÿæˆå™¨ã€åŠ¨æ€æƒé™èœå•ã€æŒ‰é’®çº§æƒé™ã€æ“ä½œæ—¥å¿—、定时任务、多租户
- ä¸Žæœ¬é¡¹ç›®å¯¹æ¯”：
  - ç›¸ä¼¼ï¼šæƒé™ä½“系设计（用户/角色/菜单/日志）与本项目同源，属业界标准做法
  - å·®è·ï¼ˆæˆ‘们缺）：代码生成器（加表时省大量重复代码）、Redis ç¼“存、定时任务、操作日志注解化
- å¯å€Ÿé‰´ï¼š**表结构变更后的一键代码生成**（RuoYi-generator）——扩展 H203-1/H204/投资模块时最实用；本项目当前扩展都是手写 Controller/Service/Mapper

### C. æŠ¥è¡¨ / BI ç”Ÿæˆ
**JimuReport（积木报表）★8k+**
- å®šä½ï¼šå¼€æºæŠ¥è¡¨å·¥å…·ï¼Œç±» Excel åœ¨çº¿æŠ¥è¡¨è®¾è®¡å™¨ + Chat2BI（对话式 AI æŠ¥è¡¨ï¼‰
- æŠ€æœ¯æ ˆï¼šSpring Boot ç³»ï¼Œå…¼å®¹å›½äº§ä¿¡åˆ›æ•°æ®æº
- ä¸Žæœ¬é¡¹ç›®å¯¹æ¯”：本项目报表用 EasyExcel + å›ºå®šæ¨¡æ¿ï¼ˆå¤Ÿç”¨ä¸”可控）；JimuReport çš„"模板在线设计"与"Chat2BI"思路与我们 AI åˆ†æžæ–¹å‘一致，但引入成本高
- å¯å€Ÿé‰´ï¼ˆè¿œæœŸï¼‰ï¼šè‹¥æŠ¥è¡¨æ•°é‡å¢žé•¿åˆ°å‡ åå¼ ï¼Œå¯è€ƒè™‘把"报表模板"配置化/在线设计化；当前阶段固定模板更稳

**DataEase â˜…24k**
- å®šä½ï¼šå¼€æº BI å·¥å…·ï¼ˆTableau æ›¿ä»£ï¼‰ï¼Œæ•°æ®æºè¿žæŽ¥ + å¯è§†åŒ– + å¤§å±
- ä¸Žæœ¬é¡¹ç›®å¯¹æ¯”：本项目不需要 BI åˆ†æžèƒ½åŠ›ï¼›ä½†æœªæ¥"数据看板"扩展（architecture.md æåˆ°çš„数据看板）可直接用 DataEase æˆ–借鉴其设计

### D. æ•°æ®è´¨é‡ / å®¡æ ¸è§„则引擎（与"审核引擎"理念最接近）
**Apache Griffin â˜…1.1k**
- å®šä½ï¼šApache é¡¶çº§é¡¹ç›®ï¼Œæ¨¡åž‹é©±åŠ¨çš„数据质量平台
- æ¨¡å¼ï¼šå®šä¹‰ measure（规则/指标）→ å®šæ—¶æ‰§è¡Œ â†’ ç”Ÿæˆè´¨é‡æŠ¥å‘Šï¼›è§„则配置化、跨数据源
- ä¸Žæœ¬é¡¹ç›®å¯¹æ¯”：**审核引擎设计理念完全一致**（audit_rule è¡¨ = measure，执行后生成 audit_result = è´¨é‡æŠ¥å‘Šï¼‰ï¼Œæˆ‘们已有雏形且更贴合业务（compare_type æ›´ä¸šåŠ¡åŒ–）

**Great Expectations â˜…11k / Soda Core â˜…2.4k**
- å®šä½ï¼šPython æ•°æ®è´¨é‡æ¡†æž¶ï¼Œå£°æ˜Žå¼ expectation/checks + æ•°æ®å¥‘约
- ä¸Žæœ¬é¡¹ç›®å¯¹æ¯”：声明式规则 + å‘Šè­¦åˆ†çº§ï¼ˆRED/YELLOW）思路与我们一致
- å¯å€Ÿé‰´ï¼šè§„则的组织方式（按表/按字段分组、规则依赖关系）、规则执行结果的可视化（Dashboard）

### E. å‰ç«¯ Excel å¯¼å…¥ç»„件
**react-spreadsheet-import â˜…553**
- å®šä½ï¼šExcel/CSV å¯¼å…¥æµç¨‹ç»„件，自动列匹配 + æ ¡éªŒ + é¢„览
- å¯å€Ÿé‰´ï¼ˆä½“验层）：导入时自动识别列名映射、导入预览、错误行高亮——本项目导入已做行号报错，可加"列名自动匹配"提升体验

## ä¸‰ã€æŠ€æœ¯æ ˆæ¨ªå‘对比

| ç»´åº¦ | æœ¬é¡¹ç›® | ä¸»æµå‚照（RuoYi ç­‰ï¼‰ | è¯„ä»· |
|------|--------|---------------------|------|
| åŽç«¯ | Spring Boot 2.x | Spring Boot 3/4 | å·²åæ—§ï¼Œä½†çŸ­æœŸä¸å½±å“å¼€å‘；长期需规划升级 |
| å‰ç«¯ | Vue 2 + Element UI | Vue 3 + Element Plus | Vue2 å·²åœæ­¢ç»´æŠ¤ï¼›çŸ­æœŸå¤Ÿç”¨ï¼Œé•¿æœŸéœ€å‡çº§ |
| æ•°æ®åº“ | MySQL 8 | MySQL/PG | æ­£å¸¸ |
| å¯¼å…¥å¯¼å‡º | EasyExcel | POI/EasyExcel | ä¸»æµ |
| æƒé™ | è‡ªç ” JWT + ä¸‰å‘˜ | Spring Security + JWT | ä¸Žä¸»æµå¯¹é½ |
| AI | DeepSeek é›†æˆ | JimuReport Chat2BI | æœ¬é¡¹ç›®åœ¨æ”¿åŠ¡åœºæ™¯æ›´å…‹åˆ¶ï¼ˆè„±æ•+解释） |

## å››ã€å¯¹æœ¬é¡¹ç›®çš„启示（开工前共识）

1. **不引入大框架重写**：无直接同类可抄，自研路线正确；RuoYi/DataEase å…¨é‡å¼•å…¥æˆæœ¬è¿œå¤§äºŽæ”¶ç›Šã€‚
2. **最值得借鉴的是 RuoYi çš„代码生成器**：扩展 H203-1/H204/投资时，若先搭一个"表结构 â†’ ç”Ÿæˆ CRUD+导入模板骨架"的小工具（或手工模板），能显著提速且保持风格一致。
3. **审核引擎继续走"规则配置化"**（audit_rule é©±åŠ¨ï¼‰ï¼Œä¸Ž Griffin/GX ç†å¿µä¸€è‡´ï¼›æ‰©å±•æ¯”较类型（MOM_EQ_ZERO/EXISTENCE/CROSS_TABLE/TREND/RATIO_CHANGE）时保持声明式，不写死。
4. **报表输出维持固定模板 + EasyExcel**，暂不上在线设计器；等报表数量多了再评估 JimuReport å¼é…ç½®åŒ–。
5. **投资模块对接"投资系统"时**，可参考 NIC MSR çš„动态数据源连接管理。
6. **技术债登记**：Vue2/SB2 å‡çº§ã€ä»£ç ç”Ÿæˆå™¨ã€æ“ä½œæ—¥å¿—注解化，列入远期清单，不阻塞当前扩展。

## äº”、检索记录（备查）

- GitHub ä¸­æ–‡å…³é”®è¯ï¼šç»Ÿè®¡æŠ¥è¡¨ç³»ç»Ÿ/报表审核/数据审核平台/报表管理 Spring Boot â†’ æ— ç›´æŽ¥åŒç±»
- GitHub è‹±æ–‡å…³é”®è¯ï¼šdata quality validation / report generation excel spring boot / data validation excel import / statistical reporting â†’ æ— ç›´æŽ¥åŒç±»
- Gitee API：未认证返回空，待补（可浏览器访问 gitee.com æœç´¢"统计报表/交通统计"人工核对）

 docs/À©Õ¹Ä£¿éÆÀ¹À.md

New file
@@ -0,0 +1,117 @@
# æ‰©å±•æ¨¡å—评估（公路旅客 / èƒ½è€— / åŸŽå¸‚客运 / æŠ•èµ„）

> æ›´æ–°æ—¥æœŸï¼š2026-08-22
> ä¾æ®ï¼š`docs/扩展表模板/` ä¸‹éœ€æ±‚文档与模板实拆（公路客运简化.docx、城市客运数据优化.docx、公路旅客运输月度生产情况.xlsx、道路货运车辆能源消耗情况（2026年）.xlsx、城市客运数据模板.xlsx、投资 è¾“å…¥/输出 æ ·ä¾‹ï¼‰ã€‚

## ä¸€ã€æ€»è§ˆï¼šæ¨¡å— Ã— çŽ°æœ‰æ¡†æž¶å¤ç”¨åº¦

| æ¨¡å— | å¯¹åº”制度表 | å¯¼å…¥ | å®¡æ ¸ | æŠ¥è¡¨ | æ¡†æž¶å¤ç”¨åº¦ | å»ºè®®æŽ’期 |
|------|-----------|------|------|------|-----------|---------|
| å…¬è·¯æ—…客运输 | äº¤ä¼ç»ŸH203-1 | é«˜ | é«˜ | é«˜ | é«˜ï¼ˆå‡ ä¹Žå…¨å¤ç”¨ï¼‰ | 1 |
| é“路货运能耗 | äº¤ä¼ç»ŸH204（季报） | ä¸­ | ä¸­ï¼ˆéœ€è·¨è¡¨å¼•ç”¨ï¼‰ | é«˜ | ä¸­é«˜ | 2 |
| åŸŽå¸‚客运（公交/出租/网约） | äº¤ä¼ç»ŸU203等 | ä¸­ï¼ˆä¾èµ–外部数据源） | ä½Žï¼ˆè§„则类型新） | ä¸­ | ä¸­ | 3 |
| æŠ•èµ„（客运站场/物流园区） | éƒ¨é—¨ç»Ÿè®¡ï¼ˆè¡¨1-1/1-2等） | ä½Žï¼ˆæ ¼å¼ä¸ç»Ÿä¸€ï¼‰ | ä½Žï¼ˆè§„则少） | ä¸­ | ä½Žï¼ˆç‹¬ç«‹å»ºæ¨¡ï¼‰ | 4 |

## äºŒã€å…¬è·¯æ—…客运输（H203-1）—— å»ºè®®æœ€å…ˆåš

### æ•°æ®ç»“构（实拆 `公路旅客运输月度生产情况.xlsx`）
- `公路旅客6月报`：企业月报明细，28 åˆ—，约 768 å®¶ä¼ä¸šã€‚字段与货运 H203-2 é«˜åº¦åŒæž„：
  - ä¼ä¸šç»´åº¦ï¼šæ‰€å±žåœ°åŒºã€ä¼ä¸šä»£ç ã€ä¼ä¸šåç§°
  - è½¦è¾†/载客位：总计、客运班车（含定线旅游）、客运包车（含非定线旅游）
  - å®¢è¿é‡/旅客周转量：总计、一类/二类/三类/四类班线、包车
  - å¹³å‡è¿è·ï¼šæ€»è®¡ã€ä¸€~四类、包车
- `运政车辆数`：4 åˆ—（企业代码、企业名称、车辆数、载客位数）——运政对比数据源（同文件内 sheet æˆ–新导入类型）
- `公路旅客分市州明细`：生成表（284 åˆ—：12 ä¸ªæœˆÃ—口径×同比+累计），口径含总客运量、公路班线、城际城乡公交、巡游出租、网约车
- `中口径计算过程`：月度汇总计算表（总客运量=班线+城际公交+巡游出租+网约车）

### å®¡æ ¸è§„则（需求原文，4 ç»„）
1. è½¦è¾†æ•°/载客位数与运政对比：车辆差距 Â±3 å°ã€è½½å®¢ä½å·®è· Â±50 â†’ æ ¸å®ž
2. å®¢è¿é‡/旅客周转量（一~四类、包车）环比上月 = 0 â†’ æ ¸å®ž
3. å¹³å‡è¿è·ï¼ˆä¸€~四类）环比 Â±10%、包车平均运距 = ä¸Šæœˆ â†’ æ ¸å®ž
4. æ— ç­çº¿å´æœ‰ç­çº¿å®¢è¿é‡ã€æ— åŒ…车却有包车客运量 â†’ æ ¸å®ž

### å¤ç”¨ç‚¹
- å¯¼å…¥ï¼šæŒ‰ä¼ä¸šé€è¡Œè§£æžï¼Œå®Œå…¨å¤ç”¨ H2032 å¯¼å…¥æ¨¡å¼ï¼ˆæ–°å¢žè§£æžå™¨+目标表即可）
- å®¡æ ¸ï¼šDIFF/RATIO/MOM å·²æœ‰ï¼›éœ€æ–°å¢ž `环比=0 æ ¸å®ž`（MOM_EQ_ZERO）与 `无车有量矛盾`（EXISTENCE）两种比较类型
- æŠ¥è¡¨ï¼šåˆ†å¸‚州明细+同比+累计，复用货运报表模式

## ä¸‰ã€é“路货运能耗（H204 å­£æŠ¥ï¼‰â€”— éœ€æ‰©å±•å®¡æ ¸å¼•æ“Ž

### æ•°æ®ç»“构（实拆 `道路货运车辆能源消耗情况（2026年）.xlsx`）
- è½¦è¾†å­£æŠ¥æ˜Žç»†ï¼š**每行一辆车**（不是每行一家企业），约 18 åˆ—：所属地区、企业代码、企业名称、车牌号、车辆类型、燃料类型、标记吨位、总行程、载货里程、空驶里程、货运量、货物周转量、平均运距、百公里单耗、周转量单耗等
- `运政车辆信息`：5 åˆ—（车牌号、车辆类型、燃料类型、标记吨位、准牵引质量）
- `能运汇总表`：生成表，13 åˆ—，按燃料类型（柴油/汽油/LNG/CNG/纯电/燃料电池）汇总

### å®¡æ ¸è§„则（需求原文，7 ç»„）
1. è½¦è¾†ç±»åž‹/燃料类型/标记吨位与运政对比，不一致 â†’ æ ¸å®ž
2. è½½è´§é‡Œç¨‹/总行程 ä¸Ž å¹³å‡è¿è·/单趟平均里程 ç›¸å·® Â±10% â†’ æ ¸å®ž
3. å„燃料类型百公里单耗超范围 â†’ æ ¸å®ž
4. åŒä¸€è¾†è½¦ç™¾å…¬é‡Œå•è€—环比 Â±50% â†’ æ ¸å®ž
5. åŒä¸€ä¼ä¸šè½¦è¾†è´§è¿é‡/周转量之和 > è´§è¿æœˆæŠ¥ 50% â†’ æ ¸å®žï¼ˆ**跨表引用货运 H203-2**）
6. è½¦è¾†å¹³å‡è¿è· ä¸Ž è´§è¿æœˆæŠ¥å¹³å‡è¿è· ç›¸å·® Â±60% â†’ æ ¸å®žï¼ˆ**跨表引用**）
7. å¹³å‡è½½è´§å¨ä½/标记吨位 å°äºŽ 0.5 æˆ–大于 1 â†’ æ ¸å®ž

### å¤ç”¨ç‚¹
- æ•°æ®æ¨¡åž‹æ˜¯"车辆"粒度，需新建 `h204_vehicle_quarterly` è¡¨ï¼Œä½†å¯¼å…¥/审核/报表链路同框架
- å®¡æ ¸å¼•æ“Žéœ€æ–°å¢ž**跨表引用**比较（CROSS_TABLE）：规则能引用另一张报表的数据做对比

## å››ã€åŸŽå¸‚客运（公交 / å·¡æ¸¸å‡ºç§Ÿ / ç½‘约车）—— è§„则最复杂

### æ•°æ®ç»“构（实拆 `城市客运数据模板.xlsx`）
- `公路总客运`、`城市客运`：均为市州级生成表（274 åˆ— / 69 åˆ—：各月客运量/周转量 + åŒæ¯” + ç´¯è®¡ï¼‰ï¼Œæ¨¡æ¿å†…公式引用外部数据（多处 #REF!，需重新接数据源）
- ç½‘约车拆分：客运量/订单总数由部级下发，巡游出租在系统内可查，需按公式拆分到各市州（Excel å†…有拆分公式，需逐格核对）

### å®¡æ ¸è§„则（需求原文）
- å…¬äº¤ 4 ç»„：城际城乡与城市内趋势一致（不一致且环比增速>2% æ ¸å®žï¼‰ï¼›å®¢è¿é‡ä¸Žå‘¨è½¬é‡è¶‹åŠ¿ä¸€è‡´ï¼›åŸŽå¸‚内占比变化>1% æ ¸å®žï¼›å¹³å‡è¿è·å˜åŒ–>3 å…¬é‡Œæ ¸å®ž
- å·¡æ¸¸å‡ºç§Ÿ 7 ç»„：运营车数与运政对比 >3%；趋势一致；客运量/周转量趋势一致；占比变化>1%；平均运距变化>3 å…¬é‡Œï¼›å•è½¦æ¬¡è½½å®¢ç³»æ•°å˜åŒ–>0.2；载客车次与客运量趋势一致
- è®¡ç®—公式：平均运距=旅客周转量/客运量；单车次载客人数=客运量/载客车次总数

### å¤ç”¨ç‚¹
- å®¡æ ¸å¼•æ“Žéœ€æ–°å¢žï¼šè¶‹åŠ¿ä¸€è‡´æ€§ï¼ˆTREND）、占比变化（RATIO_CHANGE）等比较类型
- æ•°æ®æ¥æºä¸æ­¢ Excel：部级下发网约车数、运政车辆（仅巡游出租）→ éœ€è¦å¤šæ•°æ®æºå¯¼å…¥è®¾è®¡
- å»ºè®®æŽ’第三（规则引擎扩展成本高，且依赖外部数据口径确认）

## äº”、投资模块（客运站场 / ç‰©æµå›­åŒºï¼‰â€”— ç‹¬ç«‹å»ºæ¨¡

### æ•°æ®ç»“构（实拆 `投资/` ç›®å½•ï¼‰
- è¾“入：17 å¸‚å·ž Ã— 2 ç±»ï¼ˆå®¢è¿ç«™åœºã€ç‰©æµå›­åŒºï¼‰Ã— æ¯æœˆä¸ŠæŠ¥è¡¨ï¼ˆè¡¨1-1 é¡¹ç›®æ˜Žç»†ã€è¡¨1-2 å»ºè®¾è§„模/生产能力），样例为 2026 å¹´ 6/7 æœˆ
  - **格式不统一**：列数 20~26 ä¸ç­‰ã€æ ‡é¢˜è¡Œä½ç½®ä¸åŒã€æ–‡ä»¶ç±»åž‹æ··å­˜ï¼ˆ.xls/.xlsx/.et/.pdf），市州自行填报
- è¾“出：4 å¼ å›ºå®šæ ¼å¼æ±‡æ€»è¡¨ï¼ˆç»™é¢†å¯¼ï¼‰ï¼š
  1. 2026年全省预安排计划进度情况汇总（项目进度、1-N æœˆç´¯è®¡ã€å®žé™…进度、省补资金）
  2. "十五五"规划纳入省发改委重点项目清单物流项目进展情况（表1-2+分项目投资完成情况）
  3. æ¹–北省（客货站场）（亿元投资项目）：投资总表（季度/年度完成）+ è§„上项目表（24 åˆ—）
  4. ï¼ˆç»æµŽå¼ºåŽ¿é¡¹ç›®ï¼‰æ¹–北省交通物流基础设施投资统计报表：全省货运（物流）基础设施投资月报（17 åˆ—）
- å¦æœ‰ `查询结果(投资系统-客运+物流 2026.7).xls`（8 åˆ—：单位、时期、计划总投资、累计完成、本年计划、自年初累计、当月完成）——**已有投资系统数据源可对接**

### å¤ç”¨ç‚¹
- æ•°æ®æ¨¡åž‹æ˜¯"项目"维度（项目名称、总投资、累计完成、本年计划、本月完成、进度、建筑面积），与企业/指标维度不同 â†’ æ–°å»º `investment` æ¨¡å—
- å¯¼å…¥ï¼šå„市州格式容错解析工作量最大（建议同时提供固定模板+自动识别两种路径，或直接对接投资系统）
- å®¡æ ¸ï¼šè§„则少（缺数、进度异常、与系统数比对为主）
- æŠ¥è¡¨ï¼š4 å¼ å›ºå®šæ ¼å¼æ¨¡æ¿ï¼Œå¤ç”¨æŠ¥è¡¨å¯¼å‡ºæ¡†æž¶
- æƒé™/操作日志/LLM/AI è§£é‡Šåº•åº§å¯ç›´æŽ¥å¤ç”¨

## å…­ã€å®žæ–½é¡ºåºä¸Žæž¶æž„建议

### é¡ºåºï¼ˆæŒ‰"快速见效 + é€æ­¥è¡¥èƒ½åŠ›"）
1. **公路旅客 H203-1**：验证"一套框架多张表"，成本最低
2. **能耗 H204**：补齐审核引擎"跨表引用"能力
3. **城市客运**：补齐"趋势/占比"复杂规则，确认网约车数据来源
4. **投资**：独立模块，先决策"对接投资系统 vs è§£æžå¸‚州报表"

### æž¶æž„建议（避免堆代码）
1. æŠ¥è¡¨ç±»åž‹æ³¨å†Œè¡¨åŒ–：`report_type`（现有 `audit_rule.report_type` å·²é¢„留）→ æ¯ç§æŠ¥è¡¨ = å¯¼å…¥è§£æžå™¨ + ç›®æ ‡è¡¨ + è§„则集 + æŠ¥è¡¨æ¨¡æ¿ï¼Œé€šè¿‡æ³¨å†Œè¡¨æŒ‚è½½
2. å®¡æ ¸å¼•æ“Žæ–°å¢žæ¯”较类型（可配置、规则表驱动，不写死）：
   - `MOM_EQ_ZERO`（环比=0 æ ¸å®žï¼‰ã€`EXISTENCE`（无车有量矛盾）
   - `CROSS_TABLE`（跨表引用对比）、`TREND`（趋势一致性）、`RATIO_CHANGE`（占比变化）
3. å¤šæ•°æ®æºå¯¼å…¥ï¼šExcel æ–‡ä»¶ + å¤–部系统查询导出（如投资系统）+ éƒ¨çº§ä¸‹å‘数据
4. AI è§£é‡Š/脱敏/权限全部按现有 `llmintegration`、`security` å¤ç”¨

### å·¥ä½œé‡ç²—估（单人）
| æ¨¡å— | åŽç«¯ | å‰ç«¯ | åˆè®¡ï¼ˆäººå¤©ï¼‰ |
|------|------|------|------------|
| å…¬è·¯æ—…客 H203-1 | 3~5 | 1~2 | 4~7 |
| èƒ½è€— H204 | 4~6 | 1~2 | 5~8 |
| åŸŽå¸‚客运 | 6~10 | 2~3 | 8~13 |
| æŠ•èµ„ | 8~12 | 2~3 | 10~15 |

> ä¸å«éœ€æ±‚确认、数据口径核实、联调测试时间。

 docs/Ͷ×Ê/Ä£°å/Ä£°å_ÒÚԪͶ×ÊÏîÄ¿.xls

Binary files differ

 docs/Ͷ×Ê/Ä£°å/Ä£°å_È«Ê¡Ô¤°²Åżƻ®½ø¶ÈÇé¿ö»ã×Ü.xls

Binary files differ

 docs/Ͷ×Ê/Ä£°å/Ä£°å_Ê®ÎåÎå¹æ»®ÎïÁ÷ÏîÄ¿½øÕ¹Çé¿ö.xls

Binary files differ

 docs/Ͷ×Ê/Ä£°å/Ä£°å_¾­¼ÃÇ¿ÏØͶ×Êͳ¼Æ±¨±í.xls

Binary files differ

 docs/Ͷ×Ê/Ä£°å_²éѯ½á¹û(Ͷ×Êϵͳ-¿ÍÔË+ÎïÁ÷ 2026.7).xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/¿ÍÔË£¨¿ÍÔËÕ¾£©/6ÔÂ/20260623095853.pdf

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/¿ÍÔË£¨¿ÍÔËÕ¾£©/6ÔÂ/2026Äê6ÔÂÏÌÄþÊпÍÔËÕ¾³¡Í¶×Êͳ¼ÆÔ±¨±í(1)Ê¡±í.xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/¿ÍÔË£¨¿ÍÔËÕ¾£©/6ÔÂ/2026Äê6ÔÂÁÖÇøµÀ·¿ÍÔËÕ¾³¡Í¶×Êͳ¼Æ±¨±í£¨Ô¡¢Ä걨£©.xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/¿ÍÔË£¨¿ÍÔËÕ¾£©/6ÔÂ/2026Äê¹ÌͶÔ±¨£¨ºº¿Ú¡¢ÄÏɽ£©.xlsx

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/¿ÍÔË£¨¿ÍÔËÕ¾£©/6ÔÂ/2026ºþ±±Ê¡µÀ·¿ÍÔËÕ¾³¡Í¶×Êͳ¼Æ±¨5ÔÂ(¶÷Ê©ÖÝ) (1).xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/¿ÍÔË£¨¿ÍÔËÕ¾£©/6ÔÂ/ºþ±±Ê¡Ò˲ýÊеÀ·¿ÍÔËÕ¾³¡Í¶×ʱ¨±í£¨Ô¡¢Ä걨£©06ÔÂ.xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/¿ÍÔË£¨¿ÍÔËÕ¾£©/6ÔÂ/¾£ÃÅÊпÍÔËÕ¾³¡Í¶×Êͳ¼Æ6ÔÂ.xls.xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/¿ÍÔË£¨¿ÍÔËÕ¾£©/6ÔÂ/ÏåÑôÊеÀ·ÔËÊä·þÎñÖÐÐÄ2026Äê6ÔÂͶ×Ê.et

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/¿ÍÔË£¨¿ÍÔËÕ¾£©/6ÔÂ/£¨Ð¢¸ÐÊеÀÔËÖÐÐÄ£©202606Т¸ÐÊеÀ·¿ÍÔËÕ¾³¡Í¶×Êͳ¼ÆÔ±¨±í (1).xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/¿ÍÔË£¨¿ÍÔËÕ¾£©/7ÔÂ/2026Äê7ÔÂÏÌÄþÊпÍÔËÕ¾³¡Í¶×Êͳ¼ÆÔ±¨±í(1)Ê¡±í(1).xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/¿ÍÔË£¨¿ÍÔËÕ¾£©/7ÔÂ/2026Äê7ÔÂÁÖÇøµÀ·¿ÍÔËÕ¾³¡Í¶×Êͳ¼Æ±¨±í£¨Ô¡¢Ä걨£©.xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/¿ÍÔË£¨¿ÍÔËÕ¾£©/7ÔÂ/2026Äê7ÔÂÊ¡Õ¾³¡Í¶×Ê±í£¨»Æ¸Ô£© -.xlsx

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/¿ÍÔË£¨¿ÍÔËÕ¾£©/7ÔÂ/2026Äê7ÔÂÕ¾³¡¹ÌͶ£¨ÄÏɽ¡¢ºº¿ÚÕ¾£©.xlsx

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/¿ÍÔË£¨¿ÍÔËÕ¾£©/7ÔÂ/2026ºþ±±Ê¡µÀ·¿ÍÔËÕ¾³¡Í¶×Êͳ¼Æ±¨7ÔÂ(¶÷Ê©ÖÝ).xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/¿ÍÔË£¨¿ÍÔËÕ¾£©/7ÔÂ/Ê®ÑßÊÐ2026Äê7Ô¹̶¨×ʲúÔ±¨µç×Ó°æͶ×ʱí¸ñ.xlsx

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/¿ÍÔË£¨¿ÍÔËÕ¾£©/7ÔÂ/ºþ±±Ê¡Ò˲ýÊеÀ·¿ÍÔËÕ¾³¡Í¶×ʱ¨±í£¨Ô¡¢Ä걨£©07ÔÂ.xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/¿ÍÔË£¨¿ÍÔËÕ¾£©/7ÔÂ/¾£ÃÅÊпÍÔËÕ¾³¡Í¶×Êͳ¼Æ7ÔÂ.xls.xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/¿ÍÔË£¨¿ÍÔËÕ¾£©/7ÔÂ/ÏåÑôÊеÀ·ÔËÊä·þÎñÖÐÐÄ2026Äê6ÔÂͶ×Ê (1).et

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/¿ÍÔË£¨¿ÍÔËÕ¾£©/7ÔÂ/£¨Ð¢¸ÐÊеÀÔËÖÐÐÄ£©202607Т¸ÐÊеÀ·¿ÍÔËÕ¾³¡Í¶×Êͳ¼ÆÔ±¨±í.xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/¿ÍÔË£¨¿ÍÔËÕ¾£©/¸üÐÂ_6Ô¿ÍÔËվͶ×ÊÃ÷ϸ±í.xlsx

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/¿ÍÔË£¨¿ÍÔËÕ¾£©/¸üÐÂ_7Ô¿ÍÔËվͶ×ÊÃ÷ϸ±í£¨ÊÐÖÝ»ã×Ü´ó±í£¬¸øÁìµ¼£©.xlsx

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/¿ÍÔË£¨¿ÍÔËÕ¾£©/¸ù¾Ý6ÔÂÆßÔÂÎļþ¼ÐÀïÃæµÄÊý¾Ý¸üС¶¸üÐÂ_6Ô¿ÍÔËվͶ×ÊÃ÷ϸ±í¡·ºÍ¡¶¸üÐÂ_6Ô¿ÍÔËվͶ×ÊÃ÷ϸ±í¡·Á½ÕÅ´ó±íÀïÃæµÄÊý¾Ý.txt

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/6ÔÂ/202606---»Æ¸ÔÎïÁ÷Õ¾³¡Í¶×Ê±í£¨×îÖհ棩 (1).xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/6ÔÂ/2026Äê6Ô·ÝТ¸ÐÎïÁ÷ÏîĿͶ×Êͳ¼Æ±í.xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/6ÔÂ/2026Äê6Ô·ÝÎïÁ÷£¨»õÔË£©Í¶×ÊÏîÄ¿Ã÷ϸ±í£¨»ÆʯÊУ©(1).xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/6ÔÂ/2026Äê6Ô¶÷Ê©ÖÝÎïÁ÷£¨»õÔË£©ÏîĿͶ×ÊÃ÷ϸ.xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/6ÔÂ/2026Äê6Ôºþ±±Ê¡ÏåÑôÊн»Í¨ÎïÁ÷»ù´¡ÉèʩͶ×Êͳ¼Æ±¨±í(2).xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/6ÔÂ/2026Äê6ÔÂÎïÁ÷»ù´¡ÉèÊ©½¨ÉèͶ×ÊÔ±¨.xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/6ÔÂ/2026Äê6Ô¶õÖÝÆóÒµÔ±¨»ã×Ü.xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/6ÔÂ/6ÔÂÌìÃÅ·ÝÎïÁ÷Ô°ÖÐÐĽ¨ÉèÏîÄ¿(1).xlsx

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/6ÔÂ/ÏÉÌÒÊÐÎïÁ÷԰Ͷ×Êͳ¼Æ±¨±í£¨202606£©.xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/6ÔÂ/ÏÌÄþÊÐ2026Äê6Ô·ÝÎïÁ÷£¨»õÔË£©ÏîĿͶ×ÊÃ÷ϸ.xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/6ÔÂ/±¨±í¡ªÎ人ÁùÔÂ.xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/6ÔÂ/ÁÖÇøÎïÁ÷Ͷ×ÊÔ±¨2026.06.xlsx

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/6ÔÂ/ºþ±±Ò˲ýÊÐÎïÁ÷»ù´¡ÉèʩͶ×Êͳ¼Æ±¨±í£¨Ô¡¢Ä걨£©06ÔÂ.xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/6ÔÂ/ºþ±±Ê¡Ê®Ñß½»Í¨ÎïÁ÷»ù´¡ÉèʩͶ×Êͳ¼Æ»ã×Ü±í£¨Ô±¨£©£¨2026Äê5Ô£© (2).xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/6ÔÂ/DZ½­2026.06.xlsx

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/6ÔÂ/¾£ÖÝÎïÁ÷Ͷ×Ê£¨2026Äê6Ô±¨Ê¡£© .xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/6ÔÂ/¾£ÃÅ2026Äê06ÔÂÏîĿͶ×Ê×ܱ¨±í£¨ÎïÁ÷£© (1).xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/7ÔÂ/202607---»Æ¸ÔÎïÁ÷Õ¾³¡Í¶×Ê±í£¨×îÖհ棩.xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/7ÔÂ/2026Äê7Ô·ÝТ¸ÐÎïÁ÷ÏîĿͶ×Êͳ¼Æ±í.xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/7ÔÂ/2026Äê7Ô·ÝÎïÁ÷£¨»õÔË£©Í¶×ÊÏîÄ¿Ã÷ϸ±í£¨»ÆʯÊУ© (2).xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/7ÔÂ/2026Äê7ÔÂÆóÒµÔ±¨»ã×Ü£¨¶õÖÝ£©.xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/7ÔÂ/2026Äê7Ô¶÷Ê©ÖÝÎïÁ÷£¨»õÔË£©ÏîĿͶ×ÊÃ÷ϸ .xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/7ÔÂ/2026Äê7Ôºþ±±Ê¡ÏåÑôÊн»Í¨ÎïÁ÷»ù´¡ÉèʩͶ×Êͳ¼Æ±¨±í (1).xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/7ÔÂ/2026Äê7ÔÂÎïÁ÷»ù´¡ÉèÊ©½¨ÉèͶ×ÊÔ±¨(ËæÖÝ) (1).xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/7ÔÂ/7Ô·ÝÎïÁ÷Ô°ÖÐÐĽ¨ÉèÏîÄ¿ £¨ÌìÃÅ£©.xlsx

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/7ÔÂ/ÏÉÌÒÊÐÎïÁ÷԰Ͷ×Êͳ¼Æ±¨±í£¨202607£©.xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/7ÔÂ/ÏÌÄþÊÐ2026Äê7Ô·ÝÎïÁ÷£¨»õÔË£©ÏîĿͶ×ÊÃ÷ϸ (1).xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/7ÔÂ/±¨±í¡ªÎ人ÆßÔÂ.xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/7ÔÂ/ÁÖÇøÎïÁ÷Ͷ×ÊÔ±¨2026.07.24.xlsx

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/7ÔÂ/ºþ±±Ò˲ýÊÐÎïÁ÷»ù´¡ÉèʩͶ×Êͳ¼Æ±¨±í£¨Ô¡¢Ä걨£©07ÔÂ.xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/7ÔÂ/ºþ±±Ê¡Ê®Ñß½»Í¨ÎïÁ÷»ù´¡ÉèʩͶ×Êͳ¼Æ»ã×Ü±í£¨Ô±¨£©£¨2026Äê7Ô£©.xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/7ÔÂ/DZ½­2026.07.xlsx

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/7ÔÂ/¾£ÖÝÎïÁ÷Ͷ×Ê£¨2026Äê7Ô±¨Ê¡£© .xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/7ÔÂ/¾£ÃÅ2026Äê07ÔÂÏîĿͶ×Ê×ܱ¨±í£¨ÎïÁ÷£©.xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/¸üÐÂ_6ÔÂÎïÁ÷Õ¾³¡Í¶×ÊÃ÷ϸ.xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/¸üÐÂ_7ÔÂÎïÁ÷Õ¾³¡Í¶×ÊÃ÷ϸ.xls

Binary files differ

 docs/Ͷ×Ê/ÊäÈë/ÎïÁ÷£¨ÎïÁ÷Ô°Çø£©/¸ù¾Ý6ÔÂ7ÔÂÎļþ¼ÐÀïÃæµÄÊý¾Ý·Ö±ð¸üС¶6ÔÂÎïÁ÷Õ¾³¡Í¶×ÊÃ÷ϸ¡·ºÍ¡¶7ÔÂÎïÁ÷Õ¾³¡Í¶×ÊÃ÷ϸ¡·ÀïÃæµÄÏîÄ¿ºÍÊý¾Ý.txt

 docs/Ͷ×Ê/ÊäÈëµÄÄÚÈÝÒªÓ롶ģ°å_²éѯ½á¹û(Ͷ×Êϵͳ-¿ÍÔË+ÎïÁ÷ 2026.7)¡·½øÐÐУÑ飬´æÔÚÊý¾Ý²»Ò»Öµĵ¯´°Ìáʾ.txt

 docs/Ͷ×Ê/Êä³ö/2026ÄêÈ«Ê¡Ô¤°²Åżƻ®½ø¶ÈÇé¿ö»ã×Ü£¨7Ô£©.xls

Binary files differ

 docs/Ͷ×Ê/Êä³ö/¡°Ê®ÎåÎ塱¹æ»®ÄÉÈëÊ¡·¢¸ÄίÖصãÏîÄ¿Çåµ¥ÎïÁ÷ÏîÄ¿½øÕ¹Çé¿ö£¨7Ô£©1.xls

Binary files differ

 docs/Ͷ×Ê/Êä³ö/ÿ¸öÔÂ×ö³öÕâЩ¹Ì¶¨¸ñʽµÄ±í£¬¸øÁìµ¼¿´.txt

 docs/Ͷ×Ê/Êä³ö/ºþ±±Ê¡£¨¿Í»õÕ¾³¡£©£¨ÒÚԪͶ×ÊÏîÄ¿£©7ÔÂ.xls

Binary files differ

 docs/Ͷ×Ê/Êä³ö/£¨¾­¼ÃÇ¿ÏØÏîÄ¿£©ºþ±±Ê¡½»Í¨ÎïÁ÷»ù´¡ÉèʩͶ×Êͳ¼Æ±¨±í£¨7ÔÂÔ±¨£©xls.xls

Binary files differ

 docs/Ͷ×ÊÄ£¿éʵʩ·½°¸.md

New file
@@ -0,0 +1,118 @@
# æŠ•èµ„模块实施方案（客运站场 / ç‰©æµå›­åŒºï¼‰

> åŸºäºŽ `docs/扩展表模板/投资/` å…¨éƒ¨æ ·ä¾‹å®žæ‹†æ•´ç†ï¼ˆ2026-08-23）
> ç»“论先行：**主数据源走"全省汇总大表 + å¸‚州上报表解析"，投资系统导出仅作审核比对**；建议分两期落地，第一期先让 4 å¼ é¢†å¯¼æŠ¥è¡¨è·‘通。

## ä¸€ã€æ•°æ®æºå®žæ‹†ç»“论

### 1. æŠ•èµ„系统查询导出（最干净，但字段最少）
`查询结果(投资系统-客运+物流 2026.7).xls`（149 è¡Œ Ã— 8 åˆ—）：

| åˆ— | å­—段 | æ ·ä¾‹ |
|----|------|------|
| A | è¡Œå· | 2 |
| B | å•ä½ï¼ˆå³é¡¹ç›®åç§°ï¼‰ | æ±‰å£å®¢è¿ä¸­å¿ƒ |
| C | æ—¶æœŸ | 2026å¹´7月 |
| D | è®¡åˆ’总投资 | 315700 |
| E | è‡ªå¼€å§‹å»ºè®¾è‡³æœ¬æœˆç´¯è®¡å®ŒæˆæŠ•èµ„ | 177685.4 |
| F | æœ¬å¹´è®¡åˆ’投资 | 30000 |
| G | è‡ªå¹´åˆç´¯è®¡å®ŒæˆæŠ•èµ„ | 4000 |
| H | å½“月完成投资 | 500 |

- ä¼˜ç‚¹ï¼šç»“构固定、无需容错解析。
- å±€é™ï¼š**无市州、无进度/形象进度/批复文号**，只能支撑 4 å¼ è¾“出表里的数值列，不足以独立生成领导报表。

### 2. å¸‚州上报表（格式不统一，需容错解析）
- å®¢è¿ç«™åœºæ ·ä¾‹ï¼šå®œæ˜Œ 18 åˆ—、汇总大表 20 åˆ—；物流样例：黄石 23 åˆ—、汇总表 24 åˆ—。
- å…¬å…±å­—段（列位置因表而异，须按表头关键词匹配）：
  åºå· / é¡¹ç›®åç§°åŠç«™çº§ / æŠ•èµ„建设单位 / å»ºè®¾æ€§è´¨ï¼ˆæ–°å»º/续建/改扩建）/ å¼€å·¥æ—¶é—´ / ç«£å·¥æ—¶é—´ / è®¡åˆ’总投资 / è‡ªå¼€å§‹å»ºè®¾ç´¯è®¡å®ŒæˆæŠ•èµ„ / æœ¬å¹´è®¡åˆ’投资 / è‡ªå¹´åˆç´¯è®¡å®ŒæˆæŠ•èµ„ / å…¶ä¸­æœ¬æœˆå®ŒæˆæŠ•èµ„ / å»ºè®¾é˜¶æ®µï¼ˆåœ¨å»º/完工/前期）/ å½¢è±¡è¿›åº¦ / å·¥å¯æ‰¹å¤ / åˆè®¾æ‰¹å¤ / å»ºç­‘面积 / ç”¨å·¥äººæ•°ã€‚
- åˆ†ç»„行：`一、使用交通部车购税资金建设项目`、`二、使用省燃油税返还资金建设项目`、`三、农村综合运输服务站/一般项目`、`四、候车亭/农村综合服务站`、`五、计划外项目`；市州小计行含"小计/合计"。
- æ–‡ä»¶æ··å­˜ï¼š`.xls / .xlsx / .et / .pdf`，标题行位置不一（部分无标题直接是表头）。

### 3. å…¨çœæ±‡æ€»ä¸­é—´è¡¨ï¼ˆæŽ¨èä¸€æœŸä¸»å…¥å£ï¼‰
- `6月/7月客运站投资明细表.xlsx`：两 sheet（明细 121 è¡Œ Ã— 20 åˆ— + æ±‡æ€»ï¼‰ï¼Œå·²æ˜¯å…¨çœ 17 å¸‚州分组合计结构，格式统一。
- `6月物流站场投资明细.xls`：4 sheet（月2 å»ºè®¾è§„模表 / åˆ†é¡¹ç›®æŠ•èµ„完成情况 / åˆ†å¸‚州规划内外项目完成情况 / å¸‚州汇总），格式统一。

### 4. è¾“出 4 å¼ è¡¨ï¼ˆç»™é¢†å¯¼ï¼Œéœ€æ±‚见 `每个月做出这些固定格式的表，给领导看.txt`）
| # | è¡¨å | ç»“æž„ | å…³é”®å£å¾„ |
|---|------|------|---------|
| 1 | 2026年全省预安排计划进度情况汇总 | 28 åˆ—，双层表头；合计/客运站场/物流 å¤§å— + 17 å¸‚州小计 + é¡¹ç›®æ˜Žç»† | åºå·/市州/县区/项目/性质/建设时间/总投资/累计完成/2026年计划(合计·部·省·自筹·进度)/2026·2027建议计划/前期工作/1-N月累计完成/实际进度/省补资金/备注 |
| 2 | "十五五"规划物流项目进展 | å¸‚州小计 + é¡¹ç›®æ˜Žç»† | åºå·/项目/企业/开工/完工/总投资/累计完成/本月完成/进度/进展描述 |
| 3 | æ¹–北省（客货站场）亿元投资项目 | 2 sheet：投资总表(6列季度口径) + è§„上项目表(24列) | è§„上项目：省份/市州/项目/类别/建设内容/状态/性质/开工/总投资/累计/各月计划与完成；**筛选≥1亿元项目** |
| 4 | ï¼ˆç»æµŽå¼ºåŽ¿é¡¹ç›®ï¼‰äº¤é€šç‰©æµåŸºç¡€è®¾æ–½æŠ•èµ„统计 | 17 åˆ— | åºå·/项目/企业/总投资/累计完成/本年计划/自年初累计/本月完成/进度/进展/工可初设批复 |

**洞察**：4 å¼ è¾“出表是同一批项目数据的 4 ç§è§†è§’（全省计划全景 / åäº”五物流重点 / äº¿å…ƒè§„模以上 / ç»æµŽå¼ºåŽ¿ï¼‰ï¼ŒæŠ½ä¸€å¥—项目主档即可复用。

## äºŒã€æ•°æ®æ¨¡åž‹ï¼ˆå»ºè®® 2 å¼ è¡¨ï¼‰

### investment_project é¡¹ç›®ä¸»æ¡£ï¼ˆæŒ‰é¡¹ç›®å+类型唯一）
| å­—段 | è¯´æ˜Ž |
|------|------|
| id / project_name | ä¸»é”® / é¡¹ç›®åç§°ï¼ˆå”¯ä¸€é”®ï¼šproject_name + category） |
| category | å®¢è¿ç«™åœº / ç‰©æµå›­åŒº |
| city / county | å¸‚å·ž / åŽ¿ï¼ˆå¸‚、区） |
| construct_nature | æ–°å»º/续建/改扩建 |
| start_year / end_year | å¼€å·¥ / ç«£å·¥æ—¶é—´ |
| total_investment | è®¡åˆ’总投资（万元，double） |
| approval_gk / approval_cs | å·¥å¯ / åˆè®¾æ‰¹å¤æ–‡å· |
| planned_level | æ˜¯å¦ 2026 é¢„安排计划内 / "十五五"重点 / äº¿å…ƒé¡¹ç›®æ ‡è®° |
| source | æ•°æ®æ¥æºï¼ˆå…¨çœæ±‡æ€»è¡¨/市州报表/系统导出） |

### investment_monthly æœˆåº¦å®Œæˆè¡¨ï¼ˆreport_period + project_id）
| å­—段 | è¯´æ˜Ž |
|------|------|
| report_period | æŠ¥è¡¨æœŸ 2026-07 |
| project_id | å…³è”主档 |
| year_plan | æœ¬å¹´è®¡åˆ’投资 |
| year_cum | è‡ªå¹´åˆç´¯è®¡å®ŒæˆæŠ•èµ„ |
| month_done | å½“月完成投资 |
| start_cum | è‡ªå¼€å§‹å»ºè®¾ç´¯è®¡å®ŒæˆæŠ•èµ„ |
| progress_stage / progress_desc | å»ºè®¾é˜¶æ®µ / å½¢è±¡è¿›åº¦ |
| building_area | å»ºç­‘面积（客运表） |

> æŠ¥è¡¨æœŸä»¥é¡µé¢é€‰æ‹©ä¸ºå‡†ï¼›é‡‘额/面积统一 double å­˜å‚¨ï¼Œä¸åš BigDecimal。

## ä¸‰ã€å¯¼å…¥è®¾è®¡ï¼ˆä¸¤æœŸï¼‰

### ä¸€æœŸï¼šå…¨çœæ±‡æ€»å¤§è¡¨ + ç³»ç»Ÿå¯¼å‡ºï¼ˆå¿«é€Ÿè·‘通 4 å¼ è¡¨ï¼‰
- æ–°å¢žå¯¼å…¥ç±»åž‹"投资月报"：支持 `6月/7月客运站投资明细表.xlsx`（明细 sheet）与 `6月物流站场投资明细.xls`（分项目投资完成情况 sheet）两类统一格式。
- è§£æžè¦ç‚¹ï¼šè·³è¿‡åˆ†ç»„è¡Œ/小计行（关键词：市州名+数字列、`小计/合计`、`一、二、三…`），识别项目明细行；表头按关键词映射列。
- å¹‚等：同报表期删除旧数据（主档按名 upsert，月度表按 period åˆ é™¤é‡å»ºï¼‰ã€‚
- åŒæ—¶å¯¼å…¥ `查询结果(投资系统…).xls` ä½œä¸ºå®¡æ ¸æ¯”对基准（存 `investment_system` è¡¨æˆ–直接审核时读文件→建议存表）。

### äºŒæœŸï¼š17 å¸‚州单表容错解析
- è§£æžå™¨ä¸‰çº§å®¹é”™ï¼šâ‘ æŒ‰å…³é”®è¯å®šä½è¡¨å¤´è¡Œï¼ˆ`项目名称`+`总投资`）→ â‘¡æŒ‰è¡¨å¤´å…³é”®è¯æ˜ å°„列（`计划.*总投资`→总投资等）→ â‘¢åˆ†ç»„/小计行过滤。
- æ ¼å¼æ³¨å†Œè¡¨ï¼šæ¯ç§å¸‚州格式 = ä¸€ä¸ªè§£æžå™¨é…ç½®ï¼ˆåˆ—映射 + æ ‡é¢˜è¡Œåç§» + è·³è¿‡è¡Œæ¨¡å¼ï¼‰ï¼Œæ–°å¢žæ ¼å¼åŠ é…ç½®ä¸æ”¹ä»£ç ã€‚
- æ”¯æŒ `.xls/.xlsx`；`.et`（WPS）与 `.pdf` å…ˆæç¤º"请另存为 xls/xlsx"。

## å››ã€å®¡æ ¸è§„则（规则表驱动，report_type=INVEST）
| è§„则 | æ¯”较类型 | è¯´æ˜Ž |
|------|---------|------|
| ä¸ŽæŠ•èµ„系统数对比 | CROSS_DIFF | è®¡åˆ’总投资/自年初累计/当月完成 ä¸Žç³»ç»Ÿå¯¼å‡ºå·®å¼‚超阈值（如总投资>5% æˆ–绝对差>100万） |
| å®Œæˆè¶…计划 | RANGE | å½“月完成 > æœ¬å¹´è®¡åˆ’剩余；累计完成 > è®¡åˆ’总投资×1.05 |
| è¿›åº¦çŸ›ç›¾ | LOGIC | é˜¶æ®µ=完工但完成率<1；阶段=在建但累计=0 |
| å¿…填缺失 | NULL_CHECK | é¡¹ç›®å/总投资/累计完成 ä¸ºç©º |

## äº”、报表生成（复用现有导出框架）
- 4 ä¸ªç«¯ç‚¹ï¼š`/api/report/export/investPlan`（预安排计划表）、`investFiveYearLogistics`（十五五物流）、`investBillion`（亿元项目，含投资总表+规上项目表两 sheet）、`investCounty`（经济强县表）。
- åŠ¨æ€æœˆä»½ï¼š`period=2026-07` â†’ æ ‡é¢˜/列头用 `1-7月累计`；市州顺序沿用 `RegionUtil.cityList()`。
- äº¿å…ƒé¡¹ç›®è¡¨ï¼šæŒ‰ `total_investment â‰¥ 10000 ä¸‡å…ƒ` ç­›é€‰ï¼›æŠ•èµ„总表按季度口径从月度完成推导（一季度=1-3月、二季度=4-6月…）。

## å…­ã€å‰ç«¯
- `DataImport.vue`：新增"投资月报"（全省汇总大表）与"投资系统导出"两种导入类型。
- `ReportExport.vue`：新增"投资报表（INVEST）"卡片，4 ä¸ªç”ŸæˆæŒ‰é’®ã€‚
- `AuditResult.vue`：报表类型增加"投资月报"（可选，二期）。

## ä¸ƒã€é‡Œç¨‹ç¢‘与工作量（单人）
| é‡Œç¨‹ç¢‘ | å†…容 | å·¥ä½œé‡ |
|--------|------|--------|
| M1 | å…¨çœæ±‡æ€»å¤§è¡¨å¯¼å…¥ + ä¸»æ¡£/月度表 + 4 å¼ æŠ¥è¡¨è¾“出 | åŽç«¯ 4~5 äººå¤© + å‰ç«¯ 1~2 äººå¤© |
| M2 | å¸‚州单表容错解析 + ç³»ç»Ÿå¯¼å‡ºæ¯”对审核 | åŽç«¯ 4~6 äººå¤© |
| M3 | å‰ç«¯å…¥å£æ•´åˆ + è”调（与市州核对 6/7 æœˆæ ·ä¾‹ï¼‰ | 2~3 äººå¤© |

> ä¸å«éœ€æ±‚确认与数据口径核实；建议 M1 å®Œæˆå³è®©ç”¨æˆ·ç”¨ 6/7 æœˆæ ·ä¾‹æ ¸å¯¹ 4 å¼ è¾“出表与现有 Excel æ˜¯å¦ä¸€è‡´ã€‚

## å…«ã€å¾…用户确认的点
1. ä¸»æ•°æ®æºï¼šå…ˆä»¥"全省汇总大表"为准（M1），还是直接上"市州单表解析"？
2. ç³»ç»Ÿå¯¼å‡ºæ˜¯å¦æ¯æœˆéƒ½æœ‰ï¼ˆå¯ä½œæ¯”对基准）？是否提供项目-市州对照（系统导出无市州字段）？
3. äº¿å…ƒé¡¹ç›®ç­›é€‰å£å¾„：≥1 äº¿ï¼ˆ10000 ä¸‡ï¼‰æ˜¯å¦å‡†ç¡®ï¼Ÿç»æµŽå¼ºåŽ¿é¡¹ç›®æ¸…单是否有固定名单？

 docs/±¨±íÉú³É½çÃæÓÅ»¯.doc

Binary files differ

 docs/±¨±íÉú³É½çÃæÓÅ»¯Ö¸Áî.docx

Binary files differ

 docs/Éú³É_ÖÜתÁ¿ÅÅÃû.xlsx

Binary files differ

 docs/Éú³É_»õÔËÁ¿·ÖÊÐÖÝÃ÷ϸ.xlsx

Binary files differ

 docs/Éú³É_»õÔËÁ¿ÅÅÃû.xlsx

Binary files differ

 docs/ÄܺÄ/Êý¾Ýµ¼Èëʧ°Ü .png

 docs/ÄܺÄ/Ä£°å_ÄܺijµÁ¾ÔËÕþÐÅÏ¢.xlsx

Binary files differ

 docs/ÄܺÄ/Ä£°å_µÀ·»õÔ˳µÁ¾ÄÜÔ´ÏûºÄÇé¿ö£¨2026£©.xlsx

Binary files differ

 docs/ÄܺÄ/Éú³É_ÄÜÔË»ã×ܱí.xlsx

Binary files differ

 docs/ÄܺÄ/Éú³ÉµÄÄÜÔË»ã×ܱíÒª¸ù¾ÝÄ£°å±í¡¶ÄÜÔË»ã×Ü±í¡·µÄÁÐ¿í¡¢±íÍ·¡¢ºÏ²¢¹æÔòÍêÈ«Ò»Ö£¬½öÌæ»»Êý¾Ý¡£µ¼³öΪExcel¸ñʽ£¬Éú³É17¸öÊÐÖݵķֱíºÍÈ«Ê¡µÄ»ã×ܱí.txt

 docs/ÄܺÄ/Äܺļò»¯.docx

Binary files differ

 docs/ÄܺÄ/Äܺļò»¯£¨2026Ä꣩.xlsx

Binary files differ

 docs/»õÔË/Ä£°å_½»ÆóͳH203-2±í_µÀ·»õÎïÔËÊäÔ¶ÈÉú²úÇé¿ö.xlsx

Binary files differ

 docs/»õÔË/Ä£°å_¹æÉϹæϲð·ÖÔËÊäÁ¿.xlsx

Binary files differ

 docs/»õÔË/Ä£°å_»õÔËÁ¿ÖÜתÁ¿.xlsx

Binary files differ

 docs/»õÔË/Ä£°å_¹ì¼£Àï³Ì.xlsx

Binary files differ

 docs/»õÔË/Ä£°å_ÔËÕþ³µÁ¾.xlsx

Binary files differ

 docs/»õÔË/Éú³É_ÖÜתÁ¿ÅÅÃû.xlsx

Binary files differ

 docs/»õÔË/Éú³É_»õÔËÁ¿·ÖÊÐÖÝÃ÷ϸ.xlsx

Binary files differ

 docs/»õÔË/Éú³É_»õÔËÁ¿ÅÅÃû.xlsx

Binary files differ

 docs/»õÔË/»õÔ˼ò»¯.docx

Binary files differ

 docs/»õÔË/»õÔ˼ò»¯¹¤×÷.xlsx

Binary files differ

 docs/»õÔ˼ò»¯.docx

Binary files differ

 dump_cells.py

File was deleted

 dump_ft_mid.py

File was deleted

 dump_ft_sample.py

File was deleted

 dump_func.py

File was deleted

 dump_gen_rank.py

File was deleted

 dump_rank2.py

File was deleted

 dump_rank_sample.py

File was deleted

 dump_xml.py

File was deleted

 fix_order.py

File was deleted

 fix_rank2.py

File was deleted

 fix_schema.py

File was deleted

 fix_schema2.py

File was deleted

 inspect_report.py

File was deleted

 inspect_report2.py

File was deleted

 patch_report.py

File was deleted

 traffic-audit-server/src/main/java/com/trafficaudit/auditengine/controller/AuditController.java

@@ -3,6 +3,7 @@
import com.trafficaudit.auditengine.entity.AuditResult;
import com.trafficaudit.auditengine.service.AuditEngineService;
import com.trafficaudit.common.Result;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
@@ -16,14 +17,58 @@
    private AuditEngineService auditService;

    @PostMapping("/execute")
    public Result<List<AuditResult>> executeAudit(@RequestParam("period") String period) {
        List<AuditResult> results = auditService.executeAudit(period);
    public Result<List<AuditResult>> executeAudit(@RequestParam("period") String period,
                                                  @RequestParam(value = "reportType", defaultValue = "H2032") String reportType) {
        List<AuditResult> results;
        if ("H2031".equals(reportType)) {
            results = auditService.executePassengerAudit(period);
        } else if ("H204".equals(reportType)) {
            results = auditService.executeEnergyAudit(period);
        } else if ("INVEST".equals(reportType)) {
            results = auditService.executeInvestmentAudit(period);
        } else if ("CITY_BUS".equals(reportType)) {
            results = auditService.executeCityBusAudit(period);
        } else if ("CITY_TAXI".equals(reportType)) {
            results = auditService.executeCityTaxiAudit(period);
        } else {
            results = auditService.executeAudit(period);
        }
        return Result.ok(results);
    }

    /** æ ‡è®°è¯¥æŠ¥è¡¨æœŸ+类型为「已审核」（线下审核通过的数据；先审核再出表的依据，导出前不再提示未审核） */
    @PostMapping("/markAudited")
    public Result<Boolean> markAudited(@RequestParam("period") String period,
                                       @RequestParam("reportType") String reportType) {
        return Result.ok(auditService.markAudited(reportType, period));
    }

    @GetMapping("/ruleStats")
    public Result<java.util.List<java.util.Map<String, Object>>> ruleStats(@RequestParam("period") String period,
                                                                           @RequestParam(value = "reportType", defaultValue = "H2032") String reportType) {
        return Result.ok(auditService.ruleStats(period, reportType));
    }

    @GetMapping("/latestPeriod")
    public Result<String> latestPeriod(@RequestParam(value = "reportType", defaultValue = "H2032") String reportType) {
        return Result.ok(auditService.latestPeriod(reportType));
    }

    @GetMapping("/export")
    public ResponseEntity<byte[]> exportResults(@RequestParam("period") String period,
                                                @RequestParam(value = "reportType", defaultValue = "H2032") String reportType) throws Exception {
        byte[] bytes = auditService.exportResults(period, reportType);
        String name = java.net.URLEncoder.encode("审核结果_" + period + ".xlsx", "UTF-8");
        return ResponseEntity.ok()
            .header("Content-Disposition", "attachment; filename*=UTF-8''" + name)
            .contentType(org.springframework.http.MediaType.APPLICATION_OCTET_STREAM)
            .body(bytes);
    }

    @GetMapping("/results")
    public Result<List<AuditResult>> getResults(@RequestParam("period") String period) {
        List<AuditResult> results = auditService.queryResults(period);
    public Result<List<AuditResult>> getResults(@RequestParam("period") String period,
                                                @RequestParam(value = "reportType", defaultValue = "H2032") String reportType) {
        List<AuditResult> results = auditService.queryResults(period, reportType);
        return Result.ok(results);
    }


 traffic-audit-server/src/main/java/com/trafficaudit/auditengine/entity/AuditRun.java

New file
@@ -0,0 +1,16 @@
package com.trafficaudit.auditengine.entity;

import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import java.time.LocalDateTime;

/** æŠ¥è¡¨æœŸå®¡æ ¸é€šè¿‡æ ‡è®°ï¼šæŸæŠ¥è¡¨ç±»åž‹æŸæŠ¥è¡¨æœŸå·²å®Œæˆå®¡æ ¸ï¼ˆçº¿ä¸‹å®¡æ ¸é€šè¿‡/系统审核执行后写入），导出前 ready æ ¡éªŒä¾æ® */
@Data
@TableName("audit_run")
public class AuditRun {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String reportType;
    private String reportPeriod;
    private LocalDateTime createdAt;
}

 traffic-audit-server/src/main/java/com/trafficaudit/auditengine/mapper/AuditRunMapper.java

New file
@@ -0,0 +1,6 @@
package com.trafficaudit.auditengine.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.trafficaudit.auditengine.entity.AuditRun;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface AuditRunMapper extends BaseMapper<AuditRun> {}

 traffic-audit-server/src/main/java/com/trafficaudit/auditengine/service/AuditEngineService.java

@@ -2,11 +2,33 @@

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.trafficaudit.auditengine.entity.AuditResult;
import com.trafficaudit.auditengine.entity.AuditRun;
import com.trafficaudit.auditengine.mapper.AuditResultMapper;
import com.trafficaudit.auditengine.mapper.AuditRunMapper;
import com.trafficaudit.dataimport.entity.EnergyAuthVehicle;
import com.trafficaudit.dataimport.entity.EnergyVehicleQuarterly;
import com.trafficaudit.dataimport.entity.H2032EnterpriseMonthly;
import com.trafficaudit.dataimport.entity.InvestmentMonthly;
import com.trafficaudit.dataimport.entity.InvestmentProject;
import com.trafficaudit.dataimport.entity.InvestmentSystem;
import com.trafficaudit.dataimport.entity.CityBusMonthly;
import com.trafficaudit.dataimport.entity.CityTaxiAuth;
import com.trafficaudit.dataimport.entity.CityTaxiMonthly;
import com.trafficaudit.dataimport.entity.PassengerAuthVehicle;
import com.trafficaudit.dataimport.entity.PassengerEnterpriseMonthly;
import com.trafficaudit.dataimport.entity.TransportAuthVehicle;
import com.trafficaudit.dataimport.entity.VehicleTrackMileage;
import com.trafficaudit.dataimport.mapper.EnergyAuthVehicleMapper;
import com.trafficaudit.dataimport.mapper.EnergyVehicleQuarterlyMapper;
import com.trafficaudit.dataimport.mapper.H2032EnterpriseMonthlyMapper;
import com.trafficaudit.dataimport.mapper.InvestmentMonthlyMapper;
import com.trafficaudit.dataimport.mapper.InvestmentProjectMapper;
import com.trafficaudit.dataimport.mapper.InvestmentSystemMapper;
import com.trafficaudit.dataimport.mapper.CityBusMonthlyMapper;
import com.trafficaudit.dataimport.mapper.CityTaxiAuthMapper;
import com.trafficaudit.dataimport.mapper.CityTaxiMonthlyMapper;
import com.trafficaudit.dataimport.mapper.PassengerAuthVehicleMapper;
import com.trafficaudit.dataimport.mapper.PassengerEnterpriseMonthlyMapper;
import com.trafficaudit.dataimport.mapper.TransportAuthVehicleMapper;
import com.trafficaudit.dataimport.mapper.VehicleTrackMileageMapper;
import com.trafficaudit.rulemanage.entity.AuditRule;
@@ -14,7 +36,13 @@
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

import javax.annotation.Resource;
import java.io.ByteArrayOutputStream;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
@@ -45,19 +73,114 @@
        FREIGHT_TYPE_NAMES.put("freightGrain", "粮食");
    }

    /** H204 è½¦è¾†ç±»åž‹ç  -> å…è®¸çš„运政车辆类型（已去掉重/中/轻型前缀） */
    private static final Map<String, java.util.Set<String>> ENERGY_VEHICLE_TYPE_ALLOWED = new HashMap<>();

    /** H204 ç‡ƒæ–™ç±»åž‹ç  -> å…è®¸çš„运政燃料类型 */
    private static final Map<String, java.util.Set<String>> ENERGY_FUEL_TYPE_ALLOWED = new HashMap<>();

    static {
        ENERGY_VEHICLE_TYPE_ALLOWED.put("01", new java.util.HashSet<>(java.util.Arrays.asList("普通货车", "栏板货车", "自卸货车")));
        ENERGY_VEHICLE_TYPE_ALLOWED.put("02", new java.util.HashSet<>(java.util.Arrays.asList("平板货车", "栏板货车")));
        ENERGY_VEHICLE_TYPE_ALLOWED.put("03", new java.util.HashSet<>(java.util.Arrays.asList("仓栅式货车")));
        ENERGY_VEHICLE_TYPE_ALLOWED.put("04", new java.util.HashSet<>(java.util.Arrays.asList("厢式货车")));
        ENERGY_VEHICLE_TYPE_ALLOWED.put("06", new java.util.HashSet<>(java.util.Arrays.asList("罐式货车")));
        ENERGY_VEHICLE_TYPE_ALLOWED.put("07", new java.util.HashSet<>(java.util.Arrays.asList("特殊结构货车", "车辆运输车")));
        ENERGY_VEHICLE_TYPE_ALLOWED.put("08", new java.util.HashSet<>(java.util.Arrays.asList("自卸货车", "栏板货车")));
        ENERGY_VEHICLE_TYPE_ALLOWED.put("09", new java.util.HashSet<>(java.util.Arrays.asList("车辆运输车", "中置轴车辆运输车")));
        ENERGY_VEHICLE_TYPE_ALLOWED.put("11", new java.util.HashSet<>(java.util.Arrays.asList("半挂牵引车")));

        ENERGY_FUEL_TYPE_ALLOWED.put("01", new java.util.HashSet<>(java.util.Arrays.asList("汽油")));
        ENERGY_FUEL_TYPE_ALLOWED.put("02", new java.util.HashSet<>(java.util.Arrays.asList("柴油")));
        ENERGY_FUEL_TYPE_ALLOWED.put("03", new java.util.HashSet<>(java.util.Arrays.asList("压缩天然气")));
        ENERGY_FUEL_TYPE_ALLOWED.put("04", new java.util.HashSet<>(java.util.Arrays.asList("液态天然气", "液化天然气", "双燃料")));
        ENERGY_FUEL_TYPE_ALLOWED.put("07", new java.util.HashSet<>(java.util.Arrays.asList("电动")));
        ENERGY_FUEL_TYPE_ALLOWED.put("08", new java.util.HashSet<>(java.util.Arrays.asList("氢气")));
    }

    @Resource
    private AuditRuleMapper ruleMapper;
    @Resource
    private AuditResultMapper resultMapper;
    @Resource
    private AuditRunMapper auditRunMapper;
    @Resource
    private H2032EnterpriseMonthlyMapper h2032Mapper;
    @Resource
    private TransportAuthVehicleMapper transportAuthMapper;
    @Resource
    private VehicleTrackMileageMapper trackMileageMapper;
    @Resource
    private PassengerEnterpriseMonthlyMapper passengerMapper;
    @Resource
    private PassengerAuthVehicleMapper passengerAuthMapper;
    @Resource
    private EnergyVehicleQuarterlyMapper energyMapper;
    @Resource
    private EnergyAuthVehicleMapper energyAuthMapper;
    @Resource
    private InvestmentProjectMapper investProjectMapper;
    @Resource
    private InvestmentMonthlyMapper investMonthlyMapper;
    @Resource
    private InvestmentSystemMapper investSystemMapper;
    @Resource
    private CityBusMonthlyMapper cityBusMapper;
    @Resource
    private CityTaxiMonthlyMapper cityTaxiMapper;
    @Resource
    private CityTaxiAuthMapper cityTaxiAuthMapper;

    /** è®°å½•ã€Œè¯¥æœŸè¯¥ç±»åž‹å·²å®Œæˆå®¡æ ¸ã€æ ‡è®°ï¼ˆå…ˆå®¡æ ¸å†å‡ºè¡¨ä¾æ®ï¼›æ— è§„则或无数据不标记，重复执行幂等） */
    public void markAudited(String reportType, String reportPeriod, List<AuditRule> rules, boolean hasData) {
        if (rules == null || rules.isEmpty() || !hasData) return;
        Long cnt = auditRunMapper.selectCount(new LambdaQueryWrapper<AuditRun>()
            .eq(AuditRun::getReportType, reportType)
            .eq(AuditRun::getReportPeriod, reportPeriod));
        if (cnt != null && cnt > 0) return;
        AuditRun run = new AuditRun();
        run.setReportType(reportType);
        run.setReportPeriod(reportPeriod);
        auditRunMapper.insert(run);
    }

    /** 2 å‚数重载：按报表类型自动取启用规则 + æ ¡éªŒè¯¥æœŸæœ‰æ•°æ®åŽå†å†™æ ‡è®°ï¼ˆçº¿ä¸‹å®¡æ ¸é€šè¿‡æ•°æ®æ‰‹åŠ¨æ ‡è®° / Controller è°ƒç”¨ï¼‰ */
    public boolean markAudited(String reportType, String reportPeriod) {
        List<AuditRule> rules = rulesOf(reportType);
        if (rules.isEmpty()) {
            log.info("markAudited skip: no enabled rules for {}", reportType);
            return false;
        }
        long dataCount;
        if ("H2031".equals(reportType)) {
            dataCount = passengerMapper.selectCount(new LambdaQueryWrapper<PassengerEnterpriseMonthly>()
                .eq(PassengerEnterpriseMonthly::getReportPeriod, reportPeriod));
        } else if ("H204".equals(reportType)) {
            dataCount = energyMapper.selectCount(new LambdaQueryWrapper<EnergyVehicleQuarterly>()
                .eq(EnergyVehicleQuarterly::getReportPeriod, reportPeriod));
        } else if ("INVEST".equals(reportType)) {
            dataCount = investMonthlyMapper.selectCount(new LambdaQueryWrapper<InvestmentMonthly>()
                .eq(InvestmentMonthly::getReportPeriod, reportPeriod));
        } else if ("CITY_BUS".equals(reportType)) {
            dataCount = cityBusMapper.selectCount(new LambdaQueryWrapper<CityBusMonthly>()
                .eq(CityBusMonthly::getReportPeriod, reportPeriod));
        } else if ("CITY_TAXI".equals(reportType)) {
            dataCount = cityTaxiMapper.selectCount(new LambdaQueryWrapper<CityTaxiMonthly>()
                .eq(CityTaxiMonthly::getReportPeriod, reportPeriod));
        } else {
            dataCount = h2032Mapper.selectCount(new LambdaQueryWrapper<H2032EnterpriseMonthly>()
                .eq(H2032EnterpriseMonthly::getReportPeriod, reportPeriod));
        }
        if (dataCount <= 0) {
            log.info("markAudited skip: no data for {} / {}", reportType, reportPeriod);
            return false;
        }
        markAudited(reportType, reportPeriod, rules, true);
        return true;
    }

    public List<AuditResult> executeAudit(String reportPeriod) {
        List<AuditRule> rules = ruleMapper.selectEnabledRules();
        List<AuditRule> rules = rulesOf("H2032");
        List<H2032EnterpriseMonthly> reports = h2032Mapper.selectList(
            new LambdaQueryWrapper<H2032EnterpriseMonthly>()
                .eq(H2032EnterpriseMonthly::getReportPeriod, reportPeriod));
@@ -90,15 +213,1062 @@
            }
        }
        log.info("Audit complete: {} reports, {} issues for {}", reports.size(), results.size(), reportPeriod);
        if (!rules.isEmpty() && !reports.isEmpty()) markAudited("H2032", reportPeriod);
        return results;
    }

    public List<AuditResult> queryResults(String reportPeriod) {
    public List<AuditResult> executePassengerAudit(String reportPeriod) {
        List<AuditRule> rules = rulesOf("H2031");
        List<PassengerEnterpriseMonthly> reports = passengerMapper.selectList(
            new LambdaQueryWrapper<PassengerEnterpriseMonthly>()
                .eq(PassengerEnterpriseMonthly::getReportPeriod, reportPeriod));

        Map<String, PassengerAuthVehicle> authMap = loadPassengerAuthMap(reportPeriod);
        Map<String, PassengerEnterpriseMonthly> lastMonthMap = loadPassengerLastMonthMap(reportPeriod);

        // å¹‚等：只清除 H2031 è§„则的旧审核结果
        List<Long> ruleIds = new ArrayList<>();
        for (AuditRule rule : rules) ruleIds.add(rule.getId());
        if (!ruleIds.isEmpty()) {
            resultMapper.delete(new LambdaQueryWrapper<AuditResult>()
                .eq(AuditResult::getReportPeriod, reportPeriod)
                .in(AuditResult::getRuleId, ruleIds));
        }

        Map<Long, AuditRule> ruleMap = new HashMap<>();
        for (AuditRule rule : rules) ruleMap.put(rule.getId(), rule);

        List<AuditResult> results = new ArrayList<>();
        for (PassengerEnterpriseMonthly report : reports) {
            for (AuditRule rule : rules) {
                AuditResult result = checkPassengerRule(rule, report, authMap, lastMonthMap);
                if (result != null) {
                    result.setRuleName(rule.getRuleName());
                    result.setRuleCode(rule.getRuleCode());
                    result.setAlertLevel(rule.getAlertLevel());
                    result.setEnterpriseName(report.getEnterpriseName());
                    result.setVerifyExplanation(report.getVerifyExplanation());
                    resultMapper.insert(result);
                    results.add(result);
                }
            }
        }
        log.info("Passenger audit complete: {} reports, {} issues for {}", reports.size(), results.size(), reportPeriod);
        if (!rules.isEmpty() && !reports.isEmpty()) markAudited("H2031", reportPeriod);
        return results;
    }


    // ========== H204 èƒ½è€—审核（车辆粒度，与运政车辆信息跨表对比） ==========

    public List<AuditResult> executeEnergyAudit(String reportPeriod) {
        List<AuditRule> rules = rulesOf("H204");
        List<EnergyVehicleQuarterly> vehicles = energyMapper.selectList(
            new LambdaQueryWrapper<EnergyVehicleQuarterly>()
                .eq(EnergyVehicleQuarterly::getReportPeriod, reportPeriod));

        Map<String, EnergyAuthVehicle> authMap = new HashMap<>();
        List<EnergyAuthVehicle> authList = energyAuthMapper.selectList(
            new LambdaQueryWrapper<EnergyAuthVehicle>()
                .eq(EnergyAuthVehicle::getReportPeriod, reportPeriod));
        for (EnergyAuthVehicle v : authList) {
            authMap.putIfAbsent(key(v.getPlateNo()), v);
        }

        // E007 çŽ¯æ¯”基准：上一季度同车牌百公里单耗
        String lastPeriod = prevQuarter(reportPeriod);
        Map<String, EnergyVehicleQuarterly> lastQuarterMap = new HashMap<>();
        if (lastPeriod != null) {
            for (EnergyVehicleQuarterly v : energyMapper.selectList(
                    new LambdaQueryWrapper<EnergyVehicleQuarterly>()
                        .eq(EnergyVehicleQuarterly::getReportPeriod, lastPeriod))) {
                lastQuarterMap.putIfAbsent(key(v.getPlateNo()), v);
            }
        }

        // E006 è¶…范围基准：本期各燃料类型百公里单耗中位数
        Map<String, Double> fuelMedianMap = fuelPer100kmMedian(vehicles);

        // E008/E009 å¯¹æ¯”基准：同期 H2032 ä¼ä¸šæœˆæŠ¥ï¼ˆæŒ‰ä¼ä¸šåç´¢å¼•ï¼‰
        Map<String, H2032EnterpriseMonthly> h2032Map = new HashMap<>();
        for (H2032EnterpriseMonthly m : h2032Mapper.selectList(
                new LambdaQueryWrapper<H2032EnterpriseMonthly>()
                    .eq(H2032EnterpriseMonthly::getReportPeriod, reportPeriod))) {
            String ent = m.getEnterpriseName();
            if (ent != null && !ent.trim().isEmpty()) h2032Map.putIfAbsent(ent.trim(), m);
        }

        // å¹‚等：只清除 H204 è§„则的旧审核结果
        List<Long> ruleIds = new ArrayList<>();
        for (AuditRule rule : rules) ruleIds.add(rule.getId());
        if (!ruleIds.isEmpty()) {
            resultMapper.delete(new LambdaQueryWrapper<AuditResult>()
                .eq(AuditResult::getReportPeriod, reportPeriod)
                .in(AuditResult::getRuleId, ruleIds));
        }

        List<AuditResult> results = new ArrayList<>();
        for (EnergyVehicleQuarterly vehicle : vehicles) {
            for (AuditRule rule : rules) {
                AuditResult result = checkEnergyRule(rule, vehicle, authMap, fuelMedianMap, lastQuarterMap, h2032Map);
                if (result != null) {
                    result.setRuleName(rule.getRuleName());
                    result.setRuleCode(rule.getRuleCode());
                    result.setAlertLevel(rule.getAlertLevel());
                    result.setEnterpriseName(vehicle.getEnterpriseName());
                    result.setVerifyExplanation(null);
                    resultMapper.insert(result);
                    results.add(result);
                }
            }
        }
        log.info("Energy audit complete: {} vehicles, {} issues for {}", vehicles.size(), results.size(), reportPeriod);
        if (!rules.isEmpty() && !vehicles.isEmpty()) markAudited("H204", reportPeriod);
        return results;
    }

    private AuditResult checkEnergyRule(AuditRule rule, EnergyVehicleQuarterly vehicle,
                                        Map<String, EnergyAuthVehicle> authMap,
                                        Map<String, Double> fuelMedianMap,
                                        Map<String, EnergyVehicleQuarterly> lastQuarterMap,
                                        Map<String, H2032EnterpriseMonthly> h2032Map) {
        try {
            switch (rule.getCompareType()) {
                case "CROSS_DIFF":
                    return checkEnergyCrossDiff(rule, vehicle, authMap);
                case "EXISTENCE_AUTH":
                    return checkEnergyExistence(rule, vehicle, authMap);
                case "LOADED_RATIO_DIFF":
                    return checkEnergyLoadedRatio(rule, vehicle);
                case "FUEL_RANGE":
                    return checkEnergyFuelRange(rule, vehicle, fuelMedianMap);
                case "FUEL_MOM":
                    return checkEnergyFuelMom(rule, vehicle, lastQuarterMap);
                case "FREIGHT_VS_H2032":
                    return checkEnergyVsFreightReport(rule, vehicle, h2032Map);
                case "AVG_DIST_VS_H2032":
                    return checkEnergyAvgDistVsFreight(rule, vehicle, h2032Map);
                case "LOADED_TON_RATIO":
                    return checkEnergyLoadedTonnageRatio(rule, vehicle);
                default:
                    return null;
            }
        } catch (Exception e) {
            log.error("Energy rule check error: {} - {}", rule.getRuleCode(), e.getMessage());
            return null;
        }
    }

    /** è·¨è¡¨å­—段对比：车辆类型/燃料类型按码表比对，标记吨位（牵引车用准牵引质量）按阈值比对 */
    private AuditResult checkEnergyCrossDiff(AuditRule rule, EnergyVehicleQuarterly vehicle,
                                             Map<String, EnergyAuthVehicle> authMap) {
        EnergyAuthVehicle auth = authMap.get(key(vehicle.getPlateNo()));
        if (auth == null) return null; // è¿æ”¿ç¼ºå¤±ç”± EXISTENCE_AUTH è§„则提示

        String field = rule.getCheckField();
        if ("vehicleType".equals(field)) {
            java.util.Set<String> allowed = ENERGY_VEHICLE_TYPE_ALLOWED.get(vehicle.getVehicleTypeCode());
            if (allowed == null || !allowed.contains(normalizeVehicleType(auth.getVehicleType()))) {
                return buildEnergyResult(rule, vehicle,
                    "能耗=" + valueOf(vehicle.getVehicleType()) + "(码" + valueOf(vehicle.getVehicleTypeCode())
                        + "), è¿æ”¿=" + valueOf(auth.getVehicleType()),
                    "车辆类型一致", "车辆类型不一致");
            }
            return null;
        }
        if ("fuelType".equals(field)) {
            java.util.Set<String> allowed = ENERGY_FUEL_TYPE_ALLOWED.get(vehicle.getFuelTypeCode());
            if (allowed == null || !allowed.contains(key(auth.getFuelType()))) {
                return buildEnergyResult(rule, vehicle,
                    "能耗=" + valueOf(vehicle.getFuelType()) + "(码" + valueOf(vehicle.getFuelTypeCode())
                        + "), è¿æ”¿=" + valueOf(auth.getFuelType()),
                    "燃料类型一致", "燃料类型不一致");
            }
            return null;
        }
        if ("markedTonnage".equals(field)) {
            double actual = nvl(vehicle.getMarkedTonnage());
            double reference = "11".equals(vehicle.getVehicleTypeCode())
                ? nvl(auth.getTractionQuality())
                : nvl(auth.getMarkedTonnage());
            double threshold = Double.parseDouble(rule.getThreshold());
            double diff = Math.abs(actual - reference);
            if (diff > threshold) {
                String refName = "11".equals(vehicle.getVehicleTypeCode()) ? "准牵引质量" : "标记吨位";
                return buildEnergyResult(rule, vehicle,
                    "能耗标记吨位=" + fmt(actual) + ", è¿æ”¿" + refName + "=" + fmt(reference),
                    "差距≤" + fmt(threshold), "差距=" + fmt(diff));
            }
            return null;
        }
        return null;
    }

    /** èƒ½è€—明细车牌在运政车辆信息中不存在时提示 */
    private AuditResult checkEnergyExistence(AuditRule rule, EnergyVehicleQuarterly vehicle,
                                             Map<String, EnergyAuthVehicle> authMap) {
        EnergyAuthVehicle auth = authMap.get(key(vehicle.getPlateNo()));
        if (auth == null) {
            return buildEnergyResult(rule, vehicle,
                "车牌号=" + vehicle.getPlateNo(), "运政车辆信息存在", "运政车辆信息缺失");
        }
        return null;
    }

    /** E005 è½½è´§é‡Œç¨‹å æ¯” vs å¹³å‡è¿è·/单趟平均里程 ç›¸å·®Â±10% */
    private AuditResult checkEnergyLoadedRatio(AuditRule rule, EnergyVehicleQuarterly vehicle) {
        double threshold = parseDoubleSafe(rule.getThreshold(), 0.1);
        double total = nvl(vehicle.getTotalMileage());
        double loaded = nvl(vehicle.getLoadedMileage());
        double avgDist = nvl(vehicle.getAvgDistance());
        double avgTrip = nvl(vehicle.getAvgTripMileage());
        if (total <= 0 || avgTrip <= 0 || avgDist <= 0) return null;
        double r1 = loaded / total;
        double r2 = avgDist / avgTrip;
        if (r2 <= 0) return null;
        double diff = Math.abs(r1 - r2) / r2;
        if (diff <= threshold) return null;
        return buildEnergyResult(rule, vehicle,
            "载货里程/总行程=" + fmt4(r1) + "，平均运距/单趟平均里程=" + fmt4(r2),
            "两者相差≤" + fmt(threshold * 100) + "%",
            "相差=" + fmt(diff * 100) + "%");
    }

    /** E006 åŒç‡ƒæ–™ç±»åž‹ç™¾å…¬é‡Œå•è€—偏离中位数超阈值（默认 50%） */
    private AuditResult checkEnergyFuelRange(AuditRule rule, EnergyVehicleQuarterly vehicle,
                                             Map<String, Double> fuelMedianMap) {
        double threshold = parseDoubleSafe(rule.getThreshold(), 0.5);
        Double v = vehicle.getFuelPer100km();
        if (v == null || v <= 0 || vehicle.getFuelTypeCode() == null) return null;
        Double median = fuelMedianMap.get(vehicle.getFuelTypeCode().trim());
        if (median == null || median <= 0) return null;
        double diff = Math.abs(v - median) / median;
        if (diff <= threshold) return null;
        return buildEnergyResult(rule, vehicle,
            "百公里单耗=" + fmt(v) + "（" + valueOf(vehicle.getFuelType()) + "），同燃料中位数=" + fmt(median),
            "偏离中位数≤" + fmt(threshold * 100) + "%",
            "偏离=" + fmt(diff * 100) + "%");
    }

    /** E007 åŒä¸€è¾†è½¦ç™¾å…¬é‡Œå•è€—环比变化超阈值（默认 Â±50%） */
    private AuditResult checkEnergyFuelMom(AuditRule rule, EnergyVehicleQuarterly vehicle,
                                           Map<String, EnergyVehicleQuarterly> lastQuarterMap) {
        double threshold = parseDoubleSafe(rule.getThreshold(), 0.5);
        Double cur = vehicle.getFuelPer100km();
        if (cur == null || cur <= 0) return null;
        EnergyVehicleQuarterly last = lastQuarterMap.get(key(vehicle.getPlateNo()));
        if (last == null || last.getFuelPer100km() == null || last.getFuelPer100km() <= 0) return null;
        double diff = Math.abs(cur - last.getFuelPer100km()) / last.getFuelPer100km();
        if (diff <= threshold) return null;
        return buildEnergyResult(rule, vehicle,
            "本期百公里单耗=" + fmt(cur) + "，上季度=" + fmt(last.getFuelPer100km()),
            "环比变化≤" + fmt(threshold * 100) + "%",
            "环比变化=" + fmt(diff * 100) + "%");
    }

    /** E008 èƒ½è€—货运量/周转量与 H2032 æœˆæŠ¥å¯¹æ¯”超阈值（默认 50%） */
    private AuditResult checkEnergyVsFreightReport(AuditRule rule, EnergyVehicleQuarterly vehicle,
                                                   Map<String, H2032EnterpriseMonthly> h2032Map) {
        double threshold = parseDoubleSafe(rule.getThreshold(), 0.5);
        String ent = vehicle.getEnterpriseName();
        if (ent == null || ent.trim().isEmpty()) return null;
        H2032EnterpriseMonthly m = h2032Map.get(ent.trim());
        if (m == null) return null;
        List<String> msgs = new ArrayList<>();
        if (m.getFreightTotal() != null && m.getFreightTotal() > 0 && vehicle.getFreight() != null) {
            double r = vehicle.getFreight() / m.getFreightTotal();
            if (r > threshold) {
                msgs.add("能耗货运量=" + fmt(vehicle.getFreight()) + "，月报=" + fmt(m.getFreightTotal())
                    + "，占比=" + fmt4(r));
            }
        }
        if (m.getTurnoverTotal() != null && m.getTurnoverTotal() > 0 && vehicle.getTurnover() != null) {
            double r = vehicle.getTurnover() / m.getTurnoverTotal();
            if (r > threshold) {
                msgs.add("能耗周转量=" + fmt(vehicle.getTurnover()) + "，月报=" + fmt(m.getTurnoverTotal())
                    + "，占比=" + fmt4(r));
            }
        }
        if (msgs.isEmpty()) return null;
        return buildEnergyResult(rule, vehicle, String.join("；", msgs),
            "能耗量≤月报" + fmt(threshold * 100) + "%", "超过月报" + fmt(threshold * 100) + "%");
    }

    /** E009 è½¦è¾†å¹³å‡è¿è·ä¸Ž H2032 æœˆæŠ¥å¹³å‡è¿è·ç›¸å·®è¶…阈值（默认 Â±60%） */
    private AuditResult checkEnergyAvgDistVsFreight(AuditRule rule, EnergyVehicleQuarterly vehicle,
                                                    Map<String, H2032EnterpriseMonthly> h2032Map) {
        double threshold = parseDoubleSafe(rule.getThreshold(), 0.6);
        String ent = vehicle.getEnterpriseName();
        if (ent == null || ent.trim().isEmpty()) return null;
        H2032EnterpriseMonthly m = h2032Map.get(ent.trim());
        if (m == null || m.getAvgDistance() == null || m.getAvgDistance() <= 0) return null;
        double cur = nvl(vehicle.getAvgDistance());
        if (cur <= 0) return null;
        double diff = Math.abs(cur - m.getAvgDistance()) / m.getAvgDistance();
        if (diff <= threshold) return null;
        return buildEnergyResult(rule, vehicle,
            "能耗平均运距=" + fmt(cur) + "，月报=" + fmt(m.getAvgDistance()),
            "相差≤" + fmt(threshold * 100) + "%",
            "相差=" + fmt(diff * 100) + "%");
    }

    /** E010 å¹³å‡è½½è´§å¨ä½/标记吨位 æ¯”值超出 [0.5, 1] */
    private AuditResult checkEnergyLoadedTonnageRatio(AuditRule rule, EnergyVehicleQuarterly vehicle) {
        double lo = 0.5, hi = 1.0;
        String t = rule.getThreshold();
        if (t != null && t.contains(",")) {
            String[] parts = t.split(",");
            try {
                lo = Double.parseDouble(parts[0].trim());
                hi = Double.parseDouble(parts[1].trim());
            } catch (Exception ignore) {
            }
        }
        double marked = nvl(vehicle.getMarkedTonnage());
        double loaded = nvl(vehicle.getAvgLoadedTonnage());
        if (marked <= 0 || loaded <= 0) return null;
        double r = loaded / marked;
        if (r >= lo && r <= hi) return null;
        return buildEnergyResult(rule, vehicle,
            "平均载货吨位=" + fmt(loaded) + "，标记吨位=" + fmt(marked) + "，比值=" + fmt4(r),
            "比值在[" + fmt(lo) + "," + fmt(hi) + "]",
            "比值=" + fmt4(r) + " è¶…出范围");
    }

    /** ä¸Šä¸€å­£åº¦æŠ¥è¡¨æœŸï¼š2026-06 â†’ 2026-03 */
    private String prevQuarter(String period) {
        if (period == null || period.length() < 7) return null;
        try {
            int year = Integer.parseInt(period.substring(0, 4));
            int month = Integer.parseInt(period.substring(5, 7));
            int pm = month - 3;
            int py = year;
            if (pm <= 0) {
                pm += 12;
                py -= 1;
            }
            return String.format("%04d-%02d", py, pm);
        } catch (Exception e) {
            return null;
        }
    }

    /** æœ¬æœŸå„燃料类型百公里单耗中位数 */
    private Map<String, Double> fuelPer100kmMedian(List<EnergyVehicleQuarterly> vehicles) {
        Map<String, List<Double>> byFuel = new HashMap<>();
        for (EnergyVehicleQuarterly v : vehicles) {
            if (v.getFuelTypeCode() == null || v.getFuelPer100km() == null || v.getFuelPer100km() <= 0) continue;
            byFuel.computeIfAbsent(v.getFuelTypeCode().trim(), k -> new ArrayList<>()).add(v.getFuelPer100km());
        }
        Map<String, Double> med = new HashMap<>();
        for (Map.Entry<String, List<Double>> e : byFuel.entrySet()) {
            List<Double> list = e.getValue();
            list.sort(null);
            double m = list.size() % 2 == 1 ? list.get(list.size() / 2)
                : (list.get(list.size() / 2 - 1) + list.get(list.size() / 2)) / 2.0;
            med.put(e.getKey(), m);
        }
        return med;
    }

    private Map<String, EnergyAuthVehicle> loadEnergyAuthMap(String reportPeriod) {
        Map<String, EnergyAuthVehicle> map = new HashMap<>();
        List<EnergyAuthVehicle> list = energyAuthMapper.selectList(
            new LambdaQueryWrapper<EnergyAuthVehicle>()
                .eq(EnergyAuthVehicle::getReportPeriod, reportPeriod));
        for (EnergyAuthVehicle v : list) {
            map.putIfAbsent(key(v.getPlateNo()), v);
        }
        return map;
    }

    /** è¿æ”¿è½¦è¾†ç±»åž‹åŽ»æŽ‰ é‡åž‹/中型/轻型 å‰ç¼€åŽæ¯”对 */
    private String normalizeVehicleType(String type) {
        if (type == null) return "";
        String t = type.trim();
        for (String prefix : new String[]{"重型", "中型", "轻型"}) {
            if (t.startsWith(prefix)) {
                t = t.substring(prefix.length());
                break;
            }
        }
        return t;
    }

    private String valueOf(String v) {
        return v == null ? "空" : v.trim();
    }

    private AuditResult buildEnergyResult(AuditRule rule, EnergyVehicleQuarterly vehicle,
                                          String actual, String threshold, String deviation) {
        AuditResult result = new AuditResult();
        result.setRuleId(rule.getId());
        result.setReportId(vehicle.getId());
        result.setEnterpriseCode(vehicle.getEnterpriseCode());
        result.setReportPeriod(vehicle.getReportPeriod());
        result.setActualValue(actual);
        result.setThresholdValue(threshold);
        result.setDeviation(deviation);
        result.setStatus("PENDING");
        return result;
    }


    // ========== INVEST æŠ•èµ„审核（汇总大表 ä¸Ž æŠ•èµ„系统导出 è·¨è¡¨å¯¹æ¯”） ==========

    public List<AuditResult> executeInvestmentAudit(String reportPeriod) {
        List<AuditRule> rules = rulesOf("INVEST");
        List<InvestmentMonthly> monthlies = investMonthlyMapper.selectList(
            new LambdaQueryWrapper<InvestmentMonthly>()
                .eq(InvestmentMonthly::getReportPeriod, reportPeriod));
        Map<Long, InvestmentProject> projectMap = new HashMap<>();
        for (InvestmentProject p : investProjectMapper.selectList(null)) {
            projectMap.put(p.getId(), p);
        }
        Map<String, List<InvestmentSystem>> sysMap = new HashMap<>();
        for (InvestmentSystem s : investSystemMapper.selectList(
                new LambdaQueryWrapper<InvestmentSystem>()
                    .eq(InvestmentSystem::getReportPeriod, reportPeriod))) {
            sysMap.computeIfAbsent(normInvestName(s.getProjectName()), k -> new ArrayList<>()).add(s);
        }

        // å¹‚等：只清除 INVEST è§„则的旧审核结果
        List<Long> ruleIds = new ArrayList<>();
        for (AuditRule rule : rules) ruleIds.add(rule.getId());
        if (!ruleIds.isEmpty()) {
            resultMapper.delete(new LambdaQueryWrapper<AuditResult>()
                .eq(AuditResult::getReportPeriod, reportPeriod)
                .in(AuditResult::getRuleId, ruleIds));
        }

        List<AuditResult> results = new ArrayList<>();
        for (InvestmentMonthly monthly : monthlies) {
            InvestmentProject project = projectMap.get(monthly.getProjectId());
            String projectName = project == null ? "未知项目" : project.getProjectName();
            InvestmentSystem sys = findInvestSystem(sysMap, projectName);
            for (AuditRule rule : rules) {
                AuditResult result = checkInvestRule(rule, monthly, projectName, sys);
                if (result != null) {
                    result.setRuleName(rule.getRuleName());
                    result.setRuleCode(rule.getRuleCode());
                    result.setAlertLevel(rule.getAlertLevel());
                    result.setEnterpriseName(projectName);
                    result.setVerifyExplanation(null);
                    resultMapper.insert(result);
                    results.add(result);
                }
            }
        }
        log.info("Investment audit complete: {} projects, {} issues for {}", monthlies.size(), results.size(), reportPeriod);
        if (!rules.isEmpty() && !monthlies.isEmpty()) markAudited("INVEST", reportPeriod);
        return results;
    }

    private AuditResult checkInvestRule(AuditRule rule, InvestmentMonthly monthly,
                                        String projectName, InvestmentSystem sys) {
        try {
            switch (rule.getCompareType()) {
                case "CROSS_DIFF":
                    return checkInvestCrossDiff(rule, monthly, projectName, sys);
                case "EXISTENCE_SYS":
                    return checkInvestExistence(rule, monthly, projectName, sys);
                default:
                    return null;
            }
        } catch (Exception e) {
            log.error("Investment rule check error: {} - {}", rule.getRuleCode(), e.getMessage());
            return null;
        }
    }

    /** ä¸ŽæŠ•èµ„系统导出数值对比：阈值格式 "绝对差|相对差%" */
    private AuditResult checkInvestCrossDiff(AuditRule rule, InvestmentMonthly monthly,
                                             String projectName, InvestmentSystem sys) {
        if (sys == null) return null; // ç¼ºå¤±ç”± EXISTENCE_SYS è§„则提示
        String field = rule.getCheckField();
        double actual;
        double reference;
        String fieldName;
        if ("startCum".equals(field)) {
            actual = nvl(monthly.getStartCum());
            reference = nvl(sys.getStartCum());
            fieldName = "自开始建设累计";
        } else if ("yearCum".equals(field)) {
            actual = nvl(monthly.getYearCum());
            reference = nvl(sys.getYearCum());
            fieldName = "自年初累计";
        } else if ("monthDone".equals(field)) {
            actual = nvl(monthly.getMonthDone());
            reference = nvl(sys.getMonthDone());
            fieldName = "本月完成";
        } else {
            return null;
        }
        String[] parts = rule.getThreshold().split("\\|");
        double absThreshold = parts.length > 0 ? parseDoubleSafe(parts[0], 50) : 50;
        double pctThreshold = parts.length > 1 ? parseDoubleSafe(parts[1], 5) : 5;
        double diff = Math.abs(actual - reference);
        double base = Math.max(Math.abs(reference), 1.0);
        double pct = diff / base * 100;
        boolean hit = diff > absThreshold && pct > pctThreshold;
        if (!hit && reference == 0 && actual > absThreshold) {
            hit = true;
        }
        if (hit) {
            return buildInvestResult(rule, monthly,
                "汇总大表" + fieldName + "=" + fmt(actual) + ", æŠ•èµ„系统=" + fmt(reference),
                "绝对差≤" + fmt(absThreshold) + "万 ä¸” ç›¸å¯¹å·®â‰¤" + fmt(pctThreshold) + "%",
                "绝对差=" + fmt(diff) + "万, ç›¸å¯¹å·®=" + fmt(Math.round(pct * 10) / 10.0) + "%");
        }
        return null;
    }

    /** æ±‡æ€»å¤§è¡¨é¡¹ç›®åœ¨æŠ•èµ„系统导出中不存在 */
    private AuditResult checkInvestExistence(AuditRule rule, InvestmentMonthly monthly,
                                             String projectName, InvestmentSystem sys) {
        if (sys == null) {
            return buildInvestResult(rule, monthly,
                "项目名称=" + projectName, "投资系统导出中存在", "投资系统导出中不存在");
        }
        return null;
    }

    private AuditResult buildInvestResult(AuditRule rule, InvestmentMonthly monthly,
                                          String actual, String threshold, String deviation) {
        AuditResult result = new AuditResult();
        result.setRuleId(rule.getId());
        result.setReportId(monthly.getId());
        result.setReportPeriod(monthly.getReportPeriod());
        result.setActualValue(actual);
        result.setThresholdValue(threshold);
        result.setDeviation(deviation);
        result.setStatus("PENDING");
        return result;
    }

    // ========== CITY_BUS åŸŽå¸‚公交审核（4 ç»„规则，企业级） ==========

    public List<AuditResult> executeCityBusAudit(String reportPeriod) {
        List<AuditRule> rules = rulesOf("CITY_BUS");
        List<CityBusMonthly> rows = cityBusMapper.selectList(
            new LambdaQueryWrapper<CityBusMonthly>()
                .eq(CityBusMonthly::getReportPeriod, reportPeriod));

        // å¹‚等：只清除 CITY_BUS è§„则的旧审核结果
        List<Long> ruleIds = new ArrayList<>();
        for (AuditRule rule : rules) ruleIds.add(rule.getId());
        if (!ruleIds.isEmpty()) {
            resultMapper.delete(new LambdaQueryWrapper<AuditResult>()
                .eq(AuditResult::getReportPeriod, reportPeriod)
                .in(AuditResult::getRuleId, ruleIds));
        }

        List<AuditResult> results = new ArrayList<>();
        for (CityBusMonthly row : rows) {
            // æ— å…¬äº¤ç»è¥æ´»åŠ¨ä¼ä¸šï¼ˆè¿è¥è½¦æ•°/客运量/周转量均 0）跳过
            if (nvl(row.getOpVehicles()) <= 0 && nvl(row.getPassengerVolume()) <= 0
                    && nvl(row.getTurnover()) <= 0) {
                continue;
            }
            for (AuditRule rule : rules) {
                AuditResult result = checkCityBusRule(rule, row);
                if (result != null) {
                    result.setRuleName(rule.getRuleName());
                    result.setRuleCode(rule.getRuleCode());
                    result.setAlertLevel(rule.getAlertLevel());
                    result.setEnterpriseName(row.getEnterpriseName());
                    result.setVerifyExplanation(row.getVerifyExplanation());
                    resultMapper.insert(result);
                    results.add(result);
                }
            }
        }
        log.info("CityBus audit complete: {} enterprises, {} issues for {}", rows.size(), results.size(), reportPeriod);
        if (!rules.isEmpty() && !rows.isEmpty()) markAudited("CITY_BUS", reportPeriod);
        return results;
    }

    private AuditResult checkCityBusRule(AuditRule rule, CityBusMonthly row) {
        try {
            switch (rule.getCompareType()) {
                case "TREND_CONSISTENCY":
                    return checkCityBusTrend(rule, row);
                case "RATIO_CHANGE":
                    return checkCityBusRatioChange(rule, row);
                case "AVG_DIST_CHANGE":
                    return checkCityBusAvgDistChange(rule, row);
                default:
                    return null;
            }
        } catch (Exception e) {
            log.error("CityBus rule check error: {} - {}", rule.getRuleCode(), e.getMessage());
            return null;
        }
    }

    /** è¶‹åŠ¿ä¸€è‡´ï¼šcheck_field ä¸­æˆå¯¹å­—段（环比/同比）趋势不一致且增速超阈值需核实 */
    private AuditResult checkCityBusTrend(AuditRule rule, CityBusMonthly row) {
        double threshold = parseDoubleSafe(rule.getThreshold(), 0.02);
        String field = rule.getCheckField() == null ? "" : rule.getCheckField();
        List<String> msgs = new ArrayList<>();
        if (field.contains("passengerCityMom")) {
            checkTrendPair(msgs, "城市内客运量环比", row.getRatePassengerCityMom(),
                "城际城乡客运量环比", row.getRateChengxiangMom(), threshold);
        }
        if (field.contains("passengerCityYoy")) {
            checkTrendPair(msgs, "城市内客运量同比", row.getRatePassengerCityYoy(),
                "城际城乡客运量同比", row.getRateChengxiangYoy(), threshold);
        }
        if (field.contains("passengerMom")) {
            checkTrendPair(msgs, "客运量环比", row.getRatePassengerMom(),
                "旅客周转量环比", row.getRateTurnoverMom(), threshold);
        }
        if (field.contains("passengerYoy")) {
            checkTrendPair(msgs, "客运量同比", row.getRatePassengerYoy(),
                "旅客周转量同比", row.getRateTurnoverYoy(), threshold);
        }
        if (msgs.isEmpty()) return null;
        return buildCityBusResult(rule, row, String.join("；", msgs),
            "两指标环比/同比趋势一致", "趋势不一致且增速超阈值");
    }

    private void checkTrendPair(List<String> msgs, String aName, Double aVal,
                                String bName, Double bVal, double threshold) {
        double a = nvl(aVal);
        double b = nvl(bVal);
        boolean aUp = a > 0, bUp = b > 0;
        boolean aDown = a < 0, bDown = b < 0;
        if ((aUp && bDown) || (aDown && bUp)) {
            double maxAbs = Math.max(Math.abs(a), Math.abs(b));
            if (maxAbs > threshold) {
                msgs.add(aName + "=" + fmt(a) + ", " + bName + "=" + fmt(b) + "（趋势不一致）");
            }
        }
    }

    /** å æ¯”变化：本月占比 vs ç”±çŽ¯æ¯”增速反推的上月占比，变化>1% éœ€æ ¸å®ž */
    private AuditResult checkCityBusRatioChange(AuditRule rule, CityBusMonthly row) {
        double threshold = parseDoubleSafe(rule.getThreshold(), 0.01);
        String field = rule.getCheckField() == null ? "" : rule.getCheckField();
        List<String> msgs = new ArrayList<>();
        if (field.contains("passengerCityRatio")) {
            Double change = cityBusRatioChange(row.getPassengerCityRatio(),
                row.getPassengerCity(), row.getRatePassengerCityMom(),
                row.getPassengerVolume(), row.getRatePassengerMom());
            if (change != null && change > threshold) {
                msgs.add("城市内客运量占比变化=" + fmt4(change) + "（>1%）");
            }
        }
        if (field.contains("chengxiangRatio")) {
            Double change = cityBusRatioChange(row.getChengxiangRatio(),
                row.getPassengerChengxiang(), row.getRateChengxiangMom(),
                row.getPassengerVolume(), row.getRatePassengerMom());
            if (change != null && change > threshold) {
                msgs.add("城际城乡客运量占比变化=" + fmt4(change) + "（>1%）");
            }
        }
        if (msgs.isEmpty()) return null;
        return buildCityBusResult(rule, row, String.join("；", msgs),
            "占比变化≤1%", "占比变化>1%");
    }

    /** å æ¯”环比变化：本月占比 vs ä¸Šæœˆå æ¯”（由环比增速反推）；无法推算返回 null */
    private Double cityBusRatioChange(Double curRatio, Double curValue, Double curRate,
                                      Double curTotal, Double totalRate) {
        if (curRatio == null) return null;
        double r = nvl(curRate);
        double tr = nvl(totalRate);
        if (r <= -1.0 || tr <= -1.0) return null;
        double lastRatio = (nvl(curValue) / (1 + r)) / (nvl(curTotal) / (1 + tr));
        if (Double.isNaN(lastRatio) || Double.isInfinite(lastRatio)) return null;
        return Math.abs(curRatio - lastRatio);
    }

    /** å¹³å‡è¿è·å˜åŒ–：环比增减（公里）或城际城乡由 å‘¨è½¬é‡/客运量 çŽ¯æ¯”反推，超过 3 å…¬é‡Œéœ€æ ¸å®ž */
    private AuditResult checkCityBusAvgDistChange(AuditRule rule, CityBusMonthly row) {
        double threshold = parseDoubleSafe(rule.getThreshold(), 3.0);
        String field = rule.getCheckField() == null ? "" : rule.getCheckField();
        List<String> msgs = new ArrayList<>();
        if (field.contains("avgDistanceMomChange")) {
            double chg = Math.abs(nvl(row.getAvgDistanceMomChange()));
            if (chg > threshold) {
                msgs.add("平均运距环比增减=" + fmt(nvl(row.getAvgDistanceMomChange())) + "公里");
            }
        }
        if (field.contains("avgDistanceCityMomChange")) {
            double chg = Math.abs(nvl(row.getAvgDistanceCityMomChange()));
            if (chg > threshold) {
                msgs.add("城市内平均运距环比增减=" + fmt(nvl(row.getAvgDistanceCityMomChange())) + "公里");
            }
        }
        if (field.contains("avgDistanceChengxiang")) {
            double cur = nvl(row.getAvgDistanceChengxiang());
            double km = nvl(row.getRateChengxiangMom());
            double kt = nvl(row.getRateChengxiangTurnoverMom());
            if (cur > 0 && km > -1.0 && kt > -1.0) {
                double last = cur * (1 + km) / (1 + kt);
                double chg = Math.abs(cur - last);
                if (chg > threshold) {
                    msgs.add("城际城乡平均运距变化=" + fmt(chg) + "公里（本月" + fmt(cur)
                        + " vs ä¸Šæœˆ" + fmt(last) + "）");
                }
            }
        }
        if (msgs.isEmpty()) return null;
        return buildCityBusResult(rule, row, String.join("；", msgs),
            "平均运距变化≤" + fmt(threshold) + "公里", "平均运距变化>" + fmt(threshold) + "公里");
    }

    private AuditResult buildCityBusResult(AuditRule rule, CityBusMonthly row,
                                           String actual, String threshold, String deviation) {
        AuditResult result = new AuditResult();
        result.setRuleId(rule.getId());
        result.setReportId(row.getId());
        result.setReportPeriod(row.getReportPeriod());
        result.setActualValue(actual);
        result.setThresholdValue(threshold);
        result.setDeviation(deviation);
        result.setStatus("PENDING");
        return result;
    }

    // ========== CITY_TAXI å·¡æ¸¸å‡ºç§Ÿå®¡æ ¸ï¼ˆ7 ç»„规则，市州级） ==========

    public List<AuditResult> executeCityTaxiAudit(String reportPeriod) {
        List<AuditRule> rules = rulesOf("CITY_TAXI");
        List<CityTaxiMonthly> rows = cityTaxiMapper.selectList(
            new LambdaQueryWrapper<CityTaxiMonthly>()
                .eq(CityTaxiMonthly::getReportPeriod, reportPeriod));

        // å¹‚等：只清除 CITY_TAXI è§„则的旧审核结果
        List<Long> ruleIds = new ArrayList<>();
        for (AuditRule rule : rules) ruleIds.add(rule.getId());
        if (!ruleIds.isEmpty()) {
            resultMapper.delete(new LambdaQueryWrapper<AuditResult>()
                .eq(AuditResult::getReportPeriod, reportPeriod)
                .in(AuditResult::getRuleId, ruleIds));
        }

        // è¿æ”¿è½¦è¾†æŒ‰å¸‚州计数（T001 å¯¹æ¯”基准）
        Map<String, Long> authCount = loadTaxiAuthCount(reportPeriod);

        List<AuditResult> results = new ArrayList<>();
        for (CityTaxiMonthly row : rows) {
            if (row.getCity() == null || row.getCity().trim().isEmpty()) continue;
            // æ— ç»è¥æ´»åŠ¨å¸‚州（运营车数/客运量/周转量均 0）跳过
            if (nvl(row.getOpVehicles()) <= 0 && nvl(row.getPassengerVolume()) <= 0
                    && nvl(row.getTurnover()) <= 0) {
                continue;
            }
            for (AuditRule rule : rules) {
                AuditResult result = checkCityTaxiRule(rule, row, authCount);
                if (result != null) {
                    result.setRuleName(rule.getRuleName());
                    result.setRuleCode(rule.getRuleCode());
                    result.setAlertLevel(rule.getAlertLevel());
                    result.setEnterpriseName(row.getCity());
                    result.setVerifyExplanation(row.getVerifyExplanation());
                    resultMapper.insert(result);
                    results.add(result);
                }
            }
        }
        log.info("CityTaxi audit complete: {} cities, {} issues for {}", rows.size(), results.size(), reportPeriod);
        if (!rules.isEmpty() && !rows.isEmpty()) markAudited("CITY_TAXI", reportPeriod);
        return results;
    }

    private Map<String, Long> loadTaxiAuthCount(String reportPeriod) {
        Map<String, Long> map = new HashMap<>();
        List<CityTaxiAuth> auths = cityTaxiAuthMapper.selectList(
            new LambdaQueryWrapper<CityTaxiAuth>()
                .eq(CityTaxiAuth::getReportPeriod, reportPeriod));
        for (CityTaxiAuth a : auths) {
            if (a.getCity() == null || a.getCity().trim().isEmpty()) continue;
            map.merge(a.getCity(), 1L, Long::sum);
        }
        return map;
    }

    private AuditResult checkCityTaxiRule(AuditRule rule, CityTaxiMonthly row, Map<String, Long> authCount) {
        try {
            switch (rule.getCompareType()) {
                case "CROSS_DIFF_PCT":
                    return checkTaxiAuthDiff(rule, row, authCount);
                case "TREND_CONSISTENCY":
                    return checkCityTaxiTrend(rule, row);
                case "RATIO_CHANGE":
                    return checkCityTaxiRatioChange(rule, row);
                case "AVG_DIST_CHANGE":
                    return checkCityTaxiAvgDistChange(rule, row);
                case "PAX_PER_TRIP_CHANGE":
                    return checkTaxiPaxPerTripChange(rule, row);
                default:
                    return null;
            }
        } catch (Exception e) {
            log.error("CityTaxi rule check error: {} - {}", rule.getRuleCode(), e.getMessage());
            return null;
        }
    }

    /** T001 è¿è¥è½¦æ•° vs è¿æ”¿åœ¨è¥è½¦è¾†æ•°ï¼šå·®å¼‚率>3% éœ€æ ¸å®žï¼ˆRED） */
    private AuditResult checkTaxiAuthDiff(AuditRule rule, CityTaxiMonthly row, Map<String, Long> authCount) {
        // æ•´æœŸæœªå¯¼å…¥è¿æ”¿æ•°æ®æ—¶è·³è¿‡å¯¹æ¯”（避免把“运政=0”误当基准报差异）
        if (authCount == null || authCount.isEmpty()) return null;
        double threshold = parseDoubleSafe(rule.getThreshold(), 3.0);
        double monthly = nvl(row.getOpVehicles());
        Long auth = authCount.get(row.getCity());
        long authV = auth == null ? 0 : auth;
        if (monthly <= 0 && authV <= 0) return null;
        double diffPct = authV <= 0 ? 100.0 : Math.abs(monthly - authV) / authV * 100.0;
        if (diffPct <= threshold) return null;
        return buildTaxiResult(rule, row,
            "月报运营车辆数=" + fmt(monthly) + "，运政在营车辆数=" + authV + "，差异率=" + fmt(diffPct) + "%",
            "差异率≤" + fmt(threshold) + "%",
            "差异率=" + fmt(diffPct) + "%>" + fmt(threshold) + "%");
    }

    /** T002/T003/T007 è¶‹åŠ¿ä¸€è‡´ï¼šcheck_field ä¸­æˆå¯¹å­—段（环比/同比）趋势不一致且增速超阈值需核实 */
    private AuditResult checkCityTaxiTrend(AuditRule rule, CityTaxiMonthly row) {
        double threshold = parseDoubleSafe(rule.getThreshold(), 0.02);
        String field = rule.getCheckField() == null ? "" : rule.getCheckField();
        List<String> msgs = new ArrayList<>();
        if (field.contains("passengerCityMom")) {
            checkTrendPair(msgs, "城市内客运量环比", row.getRatePassengerCityMom(),
                "城际城乡客运量环比", row.getRatePassengerChengxiangMom(), threshold);
        }
        if (field.contains("turnoverMomDerived")) {
            // æœˆæŠ¥æ— ç›´æŽ¥å‘¨è½¬é‡çŽ¯æ¯”列：周转量=客运量×平均运距，由两者环比推导
            Double rateTurnover = taxiTurnoverMomDerived(row);
            if (rateTurnover != null) {
                checkTrendPair(msgs, "客运量环比", row.getRatePassengerMom(),
                    "旅客周转量环比(推导)", rateTurnover, threshold);
            }
        }
        if (field.contains("tripMom")) {
            checkTrendPair(msgs, "载客车次总数环比", row.getRateTripMom(),
                "客运量环比", row.getRatePassengerMom(), threshold);
        }
        if (field.contains("tripYoy")) {
            checkTrendPair(msgs, "载客车次同比", row.getRateTripYoy(),
                "客运量同比", row.getRatePassengerYoy(), threshold);
        }
        if (msgs.isEmpty()) return null;
        return buildTaxiResult(rule, row, String.join("；", msgs),
            "两指标环比/同比趋势一致", "趋势不一致且增速超阈值");
    }

    /** æŽ¨å¯¼å‘¨è½¬é‡çŽ¯æ¯”：rate≈(1+客运量环比)×(1+平均运距环比)-1，平均运距环比由上期运距=本期−增减推算 */
    private Double taxiTurnoverMomDerived(CityTaxiMonthly row) {
        double dist = nvl(row.getAvgDistance());
        double chg = nvl(row.getAvgDistanceMomChange());
        double rp = nvl(row.getRatePassengerMom());
        if (dist <= 0 || dist - chg <= 0 || rp <= -1.0) return null;
        double rd = chg / (dist - chg);
        return (1 + rp) * (1 + rd) - 1;
    }

    /** T004 å æ¯”变化：城市内客运量占比变化>1% éœ€æ ¸å®ž */
    private AuditResult checkCityTaxiRatioChange(AuditRule rule, CityTaxiMonthly row) {
        double threshold = parseDoubleSafe(rule.getThreshold(), 0.01);
        String field = rule.getCheckField() == null ? "" : rule.getCheckField();
        List<String> msgs = new ArrayList<>();
        if (field.contains("passengerCityRatio")) {
            Double change = cityBusRatioChange(row.getPassengerCityRatio(),
                row.getPassengerCity(), row.getRatePassengerCityMom(),
                row.getPassengerVolume(), row.getRatePassengerMom());
            if (change != null && change > threshold) {
                msgs.add("城市内客运量占比变化=" + fmt4(change) + "（>1%）");
            }
        }
        if (msgs.isEmpty()) return null;
        return buildTaxiResult(rule, row, String.join("；", msgs),
            "占比变化≤1%", "占比变化>1%");
    }

    /** T005 å¹³å‡è¿è·å˜åŒ–：环比增减（公里）或城际城乡由平均运距增速反推，超过 3 å…¬é‡Œéœ€æ ¸å®ž */
    private AuditResult checkCityTaxiAvgDistChange(AuditRule rule, CityTaxiMonthly row) {
        double threshold = parseDoubleSafe(rule.getThreshold(), 3.0);
        String field = rule.getCheckField() == null ? "" : rule.getCheckField();
        List<String> msgs = new ArrayList<>();
        if (field.contains("avgDistanceMomChange")) {
            double chg = Math.abs(nvl(row.getAvgDistanceMomChange()));
            if (chg > threshold) {
                msgs.add("平均运距环比增减=" + fmt(nvl(row.getAvgDistanceMomChange())) + "公里");
            }
        }
        if (field.contains("avgDistanceCityMomChange")) {
            double chg = Math.abs(nvl(row.getAvgDistanceCityMomChange()));
            if (chg > threshold) {
                msgs.add("城市内平均运距环比增减=" + fmt(nvl(row.getAvgDistanceCityMomChange())) + "公里");
            }
        }
        if (field.contains("avgDistanceChengxiang")) {
            double cur = nvl(row.getAvgDistanceChengxiang());
            double dist = nvl(row.getAvgDistance());
            double chg = nvl(row.getAvgDistanceMomChange());
            if (cur > 0 && dist > 0 && dist > chg) {
                double rd = chg / (dist - chg);
                double last = cur / (1 + rd);
                double diff = Math.abs(cur - last);
                if (diff > threshold) {
                    msgs.add("城际城乡平均运距变化=" + fmt(diff) + "公里（本月" + fmt(cur)
                        + " vs ä¸Šæœˆ" + fmt(last) + "）");
                }
            }
        }
        if (msgs.isEmpty()) return null;
        return buildTaxiResult(rule, row, String.join("；", msgs),
            "平均运距变化≤" + fmt(threshold) + "公里", "平均运距变化>" + fmt(threshold) + "公里");
    }

    /** T006 å•è½¦æ¬¡è½½å®¢äººæ•°å˜åŒ–：由上期(载客车次/客运量环比)反推，变化>0.2人 éœ€æ ¸å®ž */
    private AuditResult checkTaxiPaxPerTripChange(AuditRule rule, CityTaxiMonthly row) {
        double threshold = parseDoubleSafe(rule.getThreshold(), 0.2);
        String field = rule.getCheckField() == null ? "" : rule.getCheckField();
        List<String> msgs = new ArrayList<>();
        if (field.contains("passengersPerTrip")) {
            double cur = nvl(row.getPassengersPerTrip());
            double rp = nvl(row.getRatePassengerMom());
            double rt = nvl(row.getRateTripMom());
            if (cur > 0 && rp > -1.0 && rt > -1.0) {
                double last = cur * (1 + rt) / (1 + rp);
                double diff = Math.abs(cur - last);
                if (diff > threshold) {
                    msgs.add("单车次载客人数变化=" + fmt(diff) + "人（本月" + fmt(cur)
                        + " vs ä¸Šæœˆ" + fmt(last) + "）");
                }
            }
        }
        if (msgs.isEmpty()) return null;
        return buildTaxiResult(rule, row, String.join("；", msgs),
            "单车次载客人数变化≤" + fmt(threshold) + "人", "单车次载客人数变化>" + fmt(threshold) + "人");
    }

    private AuditResult buildTaxiResult(AuditRule rule, CityTaxiMonthly row,
                                        String actual, String threshold, String deviation) {
        AuditResult result = new AuditResult();
        result.setRuleId(rule.getId());
        result.setReportId(row.getId());
        result.setReportPeriod(row.getReportPeriod());
        result.setActualValue(actual);
        result.setThresholdValue(threshold);
        result.setDeviation(deviation);
        result.setStatus("PENDING");
        return result;
    }

    /** é¡¹ç›®åå½’一化：去括号字符、连接符，罗马数字统一，去省/市/县/区前缀与空白 */
    private String normInvestName(String name) {
        if (name == null) return "";
        String s = name.trim();
        s = s.replaceAll("[（(]", "").replaceAll("[）)]", "");
        s = s.replaceAll("[·•—－_\\-]", "");
        s = s.replaceAll("[ⅠⅡⅢⅣⅤⅥⅦⅧⅨⅩⅰⅱⅲⅳⅴⅵⅶⅷⅸⅹ]", "I");
        s = s.replaceAll("^(湖北省|武汉市|黄石市|十堰市|宜昌市|襄阳市|鄂州市|荆门市|孝感市|荆州市|黄冈市|咸宁市|随州市|恩施州|仙桃市|潜江市|天门市|神农架林区)", "");
        s = s.replaceAll("^(?:[\\u4e00-\\u9fa5]{2,4}(?:县|市|区))", "");
        s = s.replaceAll("\\s+", "");
        return s;
    }

    /** åç§°å½’一化后精确匹配（同名多候选按县区消歧），失败再按评分做前缀/包含/子序列模糊匹配 */
    private InvestmentSystem findInvestSystem(Map<String, List<InvestmentSystem>> sysMap, String projectName) {
        String norm = normInvestName(projectName);
        if (norm.isEmpty()) return null;
        List<InvestmentSystem> exact = sysMap.get(norm);
        if (exact != null && !exact.isEmpty()) {
            return disambiguateInvest(exact, projectName);
        }
        InvestmentSystem best = null;
        int bestScore = Integer.MIN_VALUE;
        for (Map.Entry<String, List<InvestmentSystem>> e : sysMap.entrySet()) {
            String key = e.getKey();
            if (key.length() < 5 || norm.length() < 5) continue;
            String shortSide = key.length() <= norm.length() ? key : norm;
            String longSide = key.length() > norm.length() ? key : norm;
            int idx = longSide.indexOf(shortSide);
            int lenDiff = Math.abs(key.length() - norm.length());
            int score;
            if (idx == 0) {
                // å‰ç¼€å¼åŒ…含（短名=长名开头）最可信
                score = 1000 - lenDiff * 2;
            } else if (idx > 0 && shortSide.length() >= 6) {
                // ä¸­åŽéƒ¨åŒ…含：短名足够长才可信
                score = 500 - idx * 5 - lenDiff * 2 + shortSide.length();
            } else if (idx > 0 && shortSide.length() == 5 && lenDiff <= 5) {
                // 5字短名中后部：差异部分不含 åŽ¿/市/州 æ‰åŒ¹é…ï¼ˆæŽ’除 ç½—田县综合物流园 è¿™ç±»ï¼‰
                String diff = longSide.substring(0, idx) + longSide.substring(idx + shortSide.length());
                if (diff.matches(".*(县|市|州).*")) continue;
                score = 400 - idx * 5 - lenDiff;
            } else if (isInvestSubsequence(shortSide, longSide) && lenDiff <= 8) {
                // å­åºåˆ—兜底：短名为长名去掉插入词后的子序列（如 ç»¼åˆæž¢çº½ vs ç»¼åˆå®¢è¿æž¢çº½ã€ç‰©æµä¸­å¿ƒ vs ç‰©æµå›­ä¸­å¿ƒï¼‰
                score = 300 - lenDiff * 3;
            } else {
                continue;
            }
            if (score > bestScore) {
                bestScore = score;
                best = disambiguateInvest(e.getValue(), projectName);
            }
        }
        return best;
    }

    /** å¤šä¸ªç³»ç»Ÿé¡¹ç›®å½’一化后同名（如 å’¸ä¸°åŽ¿ç»¼åˆç‰©æµå›­/罗田县综合物流园 â†’ ç»¼åˆç‰©æµå›­ï¼‰ï¼ŒæŒ‰åŽ¿åŒºå‰ç¼€åŒºåˆ† */
    private InvestmentSystem disambiguateInvest(List<InvestmentSystem> candidates, String projectName) {
        if (candidates == null || candidates.isEmpty()) return null;
        if (candidates.size() == 1) return candidates.get(0);
        String county = extractCounty(projectName);
        if (!county.isEmpty()) {
            for (InvestmentSystem c : candidates) {
                String raw = c.getProjectName() == null ? "" : c.getProjectName();
                if (raw.contains(county)) return c;
            }
        }
        return candidates.get(0);
    }

    /** æå–名称中的 åŽ¿/市/区 å‰ç¼€ï¼ˆå¦‚ å’¸ä¸°åŽ¿ï¼‰ */
    private String extractCounty(String name) {
        if (name == null) return "";
        java.util.regex.Matcher m = java.util.regex.Pattern.compile("([\\u4e00-\\u9fa5]{2,4}(?:县|市|区))").matcher(name);
        if (m.find()) return m.group(1);
        return "";
    }

    /** åˆ¤æ–­çŸ­åæ˜¯å¦ä¸ºé•¿åçš„字符子序列（按顺序出现即可，允许中间插入词） */
    private boolean isInvestSubsequence(String shortSide, String longSide) {
        int i = 0;
        for (int j = 0; i < shortSide.length() && j < longSide.length(); j++) {
            if (shortSide.charAt(i) == longSide.charAt(j)) i++;
        }
        return i == shortSide.length();
    }

    private double parseDoubleSafe(String v, double def) {
        try {
            return Double.parseDouble(v.trim());
        } catch (Exception e) {
            return def;
        }
    }

    public List<AuditResult> queryResults(String reportPeriod, String reportType) {
        String type = reportType == null || reportType.trim().isEmpty() ? "H2032" : reportType.trim();
        List<AuditResult> results = resultMapper.selectList(new LambdaQueryWrapper<AuditResult>()
            .eq(AuditResult::getReportPeriod, reportPeriod)
            .orderByAsc(AuditResult::getId));
        attachInfo(results);
        return results;
        List<Long> ruleIds = new ArrayList<>();
        for (AuditRule rule : ruleMapper.selectList(null)) {
            if (type.equals(rule.getReportType())) ruleIds.add(rule.getId());
        }
        List<AuditResult> filtered = new ArrayList<>();
        for (AuditResult result : results) {
            if (ruleIds.contains(result.getRuleId())) filtered.add(result);
        }
        attachInfo(filtered);
        return filtered;
    }

    public void reviewResult(Long id, String status, String comment) {
@@ -114,11 +1284,43 @@
        if (results.isEmpty()) return;
        Map<Long, AuditRule> ruleMap = new HashMap<>();
        for (AuditRule rule : ruleMapper.selectList(null)) ruleMap.put(rule.getId(), rule);
        Map<Long, String> nameMap = new HashMap<>();
        Map<Long, String> explainMap = new HashMap<>();
        Map<Long, String> h2032Name = new HashMap<>();
        Map<Long, String> h2032Explain = new HashMap<>();
        Map<Long, String> passengerName = new HashMap<>();
        Map<Long, String> passengerExplain = new HashMap<>();
        Map<Long, String> energyName = new HashMap<>();
        Map<Long, String> investName = new HashMap<>();
        Map<Long, String> busName = new HashMap<>();
        Map<Long, String> busExplain = new HashMap<>();
        Map<Long, String> taxiName = new HashMap<>();
        Map<Long, String> taxiExplain = new HashMap<>();
        for (H2032EnterpriseMonthly r : h2032Mapper.selectList(null)) {
            nameMap.putIfAbsent(r.getId(), r.getEnterpriseName());
            explainMap.putIfAbsent(r.getId(), r.getVerifyExplanation());
            h2032Name.putIfAbsent(r.getId(), r.getEnterpriseName());
            h2032Explain.putIfAbsent(r.getId(), r.getVerifyExplanation());
        }
        for (PassengerEnterpriseMonthly r : passengerMapper.selectList(null)) {
            passengerName.putIfAbsent(r.getId(), r.getEnterpriseName());
            passengerExplain.putIfAbsent(r.getId(), r.getVerifyExplanation());
        }
        for (EnergyVehicleQuarterly r : energyMapper.selectList(null)) {
            energyName.putIfAbsent(r.getId(), r.getEnterpriseName());
        }
        for (CityBusMonthly r : cityBusMapper.selectList(null)) {
            busName.putIfAbsent(r.getId(), r.getEnterpriseName());
            busExplain.putIfAbsent(r.getId(), r.getVerifyExplanation());
        }
        for (CityTaxiMonthly r : cityTaxiMapper.selectList(null)) {
            taxiName.putIfAbsent(r.getId(), r.getCity());
            taxiExplain.putIfAbsent(r.getId(), r.getVerifyExplanation());
        }
        Map<Long, Long> investProjectId = new HashMap<>();
        for (InvestmentMonthly r : investMonthlyMapper.selectList(null)) {
            investProjectId.putIfAbsent(r.getId(), r.getProjectId());
        }
        for (InvestmentProject p : investProjectMapper.selectList(null)) {
            for (Map.Entry<Long, Long> e : investProjectId.entrySet()) {
                if (e.getValue().equals(p.getId())) investName.putIfAbsent(e.getKey(), p.getProjectName());
            }
        }
        for (AuditResult result : results) {
            AuditRule rule = ruleMap.get(result.getRuleId());
@@ -127,6 +1329,16 @@
                result.setRuleCode(rule.getRuleCode());
                result.setAlertLevel(rule.getAlertLevel());
            }
            // å„报表表 id å„自独立自增，需按规则所属报表类型分表回填企业名称
            String type = rule == null ? null : rule.getReportType();
            Map<Long, String> nameMap = "INVEST".equals(type) ? investName
                : "H204".equals(type) ? energyName
                : "H2031".equals(type) ? passengerName
                : "CITY_BUS".equals(type) ? busName
                : "CITY_TAXI".equals(type) ? taxiName : h2032Name;
            Map<Long, String> explainMap = "H2031".equals(type) ? passengerExplain
                : "CITY_BUS".equals(type) ? busExplain
                : "CITY_TAXI".equals(type) ? taxiExplain : h2032Explain;
            String enterpriseName = nameMap.get(result.getReportId());
            if (enterpriseName == null) {
                // ä¸ŠæŠ¥æ•°æ®è¢«é‡æ–°å¯¼å…¥åŽæ—§å®¡æ ¸ç»“果已失效，给出提示而非空白
@@ -135,6 +1347,214 @@
            result.setEnterpriseName(enterpriseName);
            result.setVerifyExplanation(explainMap.get(result.getReportId()));
        }
    }

    /** æœ€è¿‘有数据的报表期（用于前端默认选中） */
    public String latestPeriod(String reportType) {
        String type = reportType == null || reportType.trim().isEmpty() ? "H2032" : reportType.trim();
        String max = null;
        switch (type) {
            case "H2031":
                for (PassengerEnterpriseMonthly m : passengerMapper.selectList(
                        new LambdaQueryWrapper<PassengerEnterpriseMonthly>().select(PassengerEnterpriseMonthly::getReportPeriod))) {
                    max = maxPeriod(max, m.getReportPeriod());
                }
                break;
            case "H204":
                for (EnergyVehicleQuarterly m : energyMapper.selectList(
                        new LambdaQueryWrapper<EnergyVehicleQuarterly>().select(EnergyVehicleQuarterly::getReportPeriod))) {
                    max = maxPeriod(max, m.getReportPeriod());
                }
                break;
            case "INVEST":
                for (InvestmentMonthly m : investMonthlyMapper.selectList(
                        new LambdaQueryWrapper<InvestmentMonthly>().select(InvestmentMonthly::getReportPeriod))) {
                    max = maxPeriod(max, m.getReportPeriod());
                }
                break;
            case "CITY_BUS":
                for (CityBusMonthly m : cityBusMapper.selectList(
                        new LambdaQueryWrapper<CityBusMonthly>().select(CityBusMonthly::getReportPeriod))) {
                    max = maxPeriod(max, m.getReportPeriod());
                }
                break;
            case "CITY_TAXI":
                for (CityTaxiMonthly m : cityTaxiMapper.selectList(
                        new LambdaQueryWrapper<CityTaxiMonthly>().select(CityTaxiMonthly::getReportPeriod))) {
                    max = maxPeriod(max, m.getReportPeriod());
                }
                break;
            default:
                for (H2032EnterpriseMonthly m : h2032Mapper.selectList(
                        new LambdaQueryWrapper<H2032EnterpriseMonthly>().select(H2032EnterpriseMonthly::getReportPeriod))) {
                    max = maxPeriod(max, m.getReportPeriod());
                }
                break;
        }
        return max;
    }

    private String maxPeriod(String a, String b) {
        if (b == null || b.trim().isEmpty()) return a;
        if (a == null || a.compareTo(b) < 0) return b;
        return a;
    }

    /** å®¡æ ¸ç»“果导出 Excel（含企业名/规则名/状态/审核意见） */
    public byte[] exportResults(String reportPeriod, String reportType) throws Exception {
        List<AuditResult> results = queryResults(reportPeriod, reportType);
        try (XSSFWorkbook wb = new XSSFWorkbook()) {
            Sheet sheet = wb.createSheet("审核结果");
            String[] headers = {"报表期", "企业/市州", "规则编码", "审核规则", "等级", "实际值", "阈值/基准", "偏差说明", "状态", "审核意见"};
            Row head = sheet.createRow(0);
            for (int i = 0; i < headers.length; i++) {
                Cell cell = head.createCell(i);
                cell.setCellValue(headers[i]);
                org.apache.poi.ss.usermodel.CellStyle style = wb.createCellStyle();
                org.apache.poi.ss.usermodel.Font font = wb.createFont();
                font.setBold(true);
                style.setFont(font);
                cell.setCellStyle(style);
            }
            int r = 1;
            for (AuditResult res : results) {
                Row row = sheet.createRow(r++);
                row.createCell(0).setCellValue(valueOf(res.getReportPeriod()));
                row.createCell(1).setCellValue(valueOf(res.getEnterpriseName()));
                row.createCell(2).setCellValue(valueOf(res.getRuleCode()));
                row.createCell(3).setCellValue(valueOf(res.getRuleName()));
                row.createCell(4).setCellValue(valueOf(res.getAlertLevel()));
                row.createCell(5).setCellValue(valueOf(res.getActualValue()));
                row.createCell(6).setCellValue(valueOf(res.getThresholdValue()));
                row.createCell(7).setCellValue(valueOf(res.getDeviation()));
                row.createCell(8).setCellValue(auditStatusCn(res.getStatus()));
                row.createCell(9).setCellValue(valueOf(res.getReviewComment()));
            }
            int[] widths = {12, 28, 12, 28, 8, 36, 22, 36, 10, 28};
            for (int i = 0; i < widths.length; i++) {
                sheet.setColumnWidth(i, widths[i] * 256);
            }
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            wb.write(out);
            return out.toByteArray();
        }
    }

    private String auditStatusCn(String status) {
        if ("CONFIRMED".equals(status)) return "已确认";
        if ("IGNORED".equals(status)) return "已忽略";
        return "待处理";
    }

    /** è§„则执行统计：每条启用规则的检查对象数与命中数 */
    public List<Map<String, Object>> ruleStats(String reportPeriod, String reportType) {
        String type = reportType == null || reportType.trim().isEmpty() ? "H2032" : reportType.trim();
        List<AuditRule> rules = rulesOf(type);
        long checked;
        switch (type) {
            case "H2031":
                checked = passengerMapper.selectCount(new LambdaQueryWrapper<PassengerEnterpriseMonthly>()
                    .eq(PassengerEnterpriseMonthly::getReportPeriod, reportPeriod));
                break;
            case "H204":
                checked = energyMapper.selectCount(new LambdaQueryWrapper<EnergyVehicleQuarterly>()
                    .eq(EnergyVehicleQuarterly::getReportPeriod, reportPeriod));
                break;
            case "INVEST":
                checked = investMonthlyMapper.selectCount(new LambdaQueryWrapper<InvestmentMonthly>()
                    .eq(InvestmentMonthly::getReportPeriod, reportPeriod));
                break;
            case "CITY_BUS":
                checked = cityBusMapper.selectCount(new LambdaQueryWrapper<CityBusMonthly>()
                    .eq(CityBusMonthly::getReportPeriod, reportPeriod));
                break;
            case "CITY_TAXI":
                checked = cityTaxiMapper.selectCount(new LambdaQueryWrapper<CityTaxiMonthly>()
                    .eq(CityTaxiMonthly::getReportPeriod, reportPeriod));
                break;
            default:
                checked = h2032Mapper.selectCount(new LambdaQueryWrapper<H2032EnterpriseMonthly>()
                    .eq(H2032EnterpriseMonthly::getReportPeriod, reportPeriod));
                break;
        }
        List<AuditResult> results = resultMapper.selectList(new LambdaQueryWrapper<AuditResult>()
            .eq(AuditResult::getReportPeriod, reportPeriod));
        Map<Long, Long> hitMap = new HashMap<>();
        for (AuditResult r : results) {
            hitMap.merge(r.getRuleId(), 1L, Long::sum);
        }
        List<Map<String, Object>> out = new ArrayList<>();
        for (AuditRule rule : rules) {
            Map<String, Object> m = new HashMap<>();
            m.put("ruleId", rule.getId());
            m.put("ruleCode", rule.getRuleCode());
            m.put("ruleName", rule.getRuleName());
            m.put("alertLevel", rule.getAlertLevel());
            m.put("checked", checked);
            m.put("hit", hitMap.getOrDefault(rule.getId(), 0L));
            m.put("skipped", ruleSkipped(rule, reportPeriod));
            out.add(m);
        }
        return out;
    }

    /** è·¨è¡¨/环比基准数据整期缺失时，规则标记为跳过（避免误报） */
    private boolean ruleSkipped(AuditRule rule, String period) {
        String code = rule.getRuleCode();
        if (code == null) return false;
        switch (code) {
            case "RULE_001":
            case "RULE_002":
                return transportAuthMapper.selectCount(new LambdaQueryWrapper<TransportAuthVehicle>()
                    .eq(TransportAuthVehicle::getReportPeriod, period)) == 0;
            case "RULE_003":
                return trackMileageMapper.selectCount(new LambdaQueryWrapper<VehicleTrackMileage>()
                    .eq(VehicleTrackMileage::getReportPeriod, period)) == 0;
            case "RULE_004":
                return h2032Mapper.selectCount(new LambdaQueryWrapper<H2032EnterpriseMonthly>()
                    .eq(H2032EnterpriseMonthly::getReportPeriod, getLastPeriod(period))) == 0;
            case "RULE_P001":
            case "RULE_P002":
                return passengerAuthMapper.selectCount(new LambdaQueryWrapper<PassengerAuthVehicle>()
                    .eq(PassengerAuthVehicle::getReportPeriod, period)) == 0;
            case "RULE_P003":
            case "RULE_P004":
            case "RULE_P005":
            case "RULE_P006":
                return passengerMapper.selectCount(new LambdaQueryWrapper<PassengerEnterpriseMonthly>()
                    .eq(PassengerEnterpriseMonthly::getReportPeriod, getLastPeriod(period))) == 0;
            case "RULE_E001":
            case "RULE_E002":
            case "RULE_E003":
                return energyAuthMapper.selectCount(new LambdaQueryWrapper<EnergyAuthVehicle>()
                    .eq(EnergyAuthVehicle::getReportPeriod, period)) == 0;
            case "RULE_E008":
            case "RULE_E009":
                return h2032Mapper.selectCount(new LambdaQueryWrapper<H2032EnterpriseMonthly>()
                    .eq(H2032EnterpriseMonthly::getReportPeriod, period)) == 0;
            case "RULE_T001":
                return cityTaxiAuthMapper.selectCount(new LambdaQueryWrapper<CityTaxiAuth>()
                    .eq(CityTaxiAuth::getReportPeriod, period)) == 0;
            case "RULE_I001":
            case "RULE_I002":
            case "RULE_I003":
                return investSystemMapper.selectCount(new LambdaQueryWrapper<InvestmentSystem>()
                    .eq(InvestmentSystem::getReportPeriod, period)) == 0;
            default:
                return false;
        }
    }

    private List<AuditRule> rulesOf(String reportType) {
        List<AuditRule> all = ruleMapper.selectEnabledRules();
        List<AuditRule> matched = new ArrayList<>();
        for (AuditRule rule : all) {
            String type = rule.getReportType();
            if (reportType.equals(type) || (type == null && "H2032".equals(reportType))) {
                matched.add(rule);
            }
        }
        return matched;
    }

    private AuditResult checkRule(AuditRule rule, H2032EnterpriseMonthly report,
@@ -152,7 +1572,7 @@
                case "NULL_CHECK":
                    return checkNull(rule, report);
                case "OUT_RANGE":
                    return checkOutRange(rule, report, authMap);
                    return checkOutRange(rule, report);
                default:
                    return null;
            }
@@ -187,7 +1607,7 @@
        return null;
    }

    /** ä¸ŠæŠ¥å‘¨è½¬é‡ä¸Žè½¨è¿¹æµ‹ç®—周转量对比，高出30%核实 */
    /** ä¸ŠæŠ¥å‘¨è½¬é‡ä¸Žè½¨è¿¹æµ‹ç®—周转量对比，高出阈值比例核实 */
    private AuditResult checkRatio(AuditRule rule, H2032EnterpriseMonthly report,
                                   Map<String, TransportAuthVehicle> authMap,
                                   Map<String, VehicleTrackMileage> trackMap) {
@@ -215,67 +1635,59 @@

        if (ratio > threshold) {
            return buildResult(rule, report,
                "上报周转量=" + fmt(actual) + ", è½¨è¿¹æµ‹ç®—=" + Math.round(estimatedTurnover),
                "比值≤" + fmt(threshold), "比值=" + fmt(ratio));
                "上报周转量=" + fmt(actual) + ", è½¨è¿¹æµ‹ç®—=" + fmt(estimatedTurnover),
                "≤轨迹测算×" + fmt(threshold), "=轨迹测算×" + fmt(ratio));
        }
        return null;
    }

    /** è´§è¿ç±»åž‹çŽ¯æ¯”：本月新增货运类型核实（多的核实，少的不管） */
    /** è´§è¿ç±»åž‹çŽ¯æ¯”：本月新增（上月为0、本月>0）需核实，少的不管 */
    private AuditResult checkMom(AuditRule rule, H2032EnterpriseMonthly report,
                                 Map<String, H2032EnterpriseMonthly> lastMonthMap) {
        H2032EnterpriseMonthly lastMonth = lastMonthMap.get(key(report.getEnterpriseCode()));
        if (lastMonth == null) return null;

        String[] fields = {"freightContainer", "freightCoal", "freightOilGas", "freightCrudeOil",
            "freightMetalOre", "freightIronOre", "freightBuilding", "freightGrain"};
        List<String> newTypes = new ArrayList<>();
        for (String field : fields) {
            double current = getFieldValue(report, field);
            double last = getFieldValue(lastMonth, field);
        List<String> hits = new ArrayList<>();
        for (String field : rule.getCheckField().split(",")) {
            double current = getH2032FieldValue(report, field);
            double last = getH2032FieldValue(lastMonth, field);
            if (current > 0 && last == 0) {
                newTypes.add(FREIGHT_TYPE_NAMES.get(field) + "=" + fmt(current) + "吨");
                hits.add(h2032FieldLabel(field) + "=" + fmt(current));
            }
        }
        if (!newTypes.isEmpty()) {
            return buildResult(rule, report, "本月新增货类: " + String.join("、", newTypes),
                "上月为0", "环比新增");
        if (!hits.isEmpty()) {
            return buildResult(rule, report, "本月新增: " + String.join("、", hits),
                "上月该类型为0", "本月新增货运类型（上月无）");
        }
        return null;
    }

    /** æ— é›†è£…箱车但有集装箱货运量 */
    /** æœ‰è´§è¿é‡ä½†å¯¹åº”车辆为0 éœ€æ ¸å®žï¼ˆå¦‚ æœ‰é›†è£…箱货运量无集装箱车辆） */
    private AuditResult checkNull(AuditRule rule, H2032EnterpriseMonthly report) {
        double containerFreight = nvl(report.getFreightContainer());
        double containerVehicle = nvl(report.getVehicleContainer());
        if (containerFreight > 0 && containerVehicle == 0) {
            return buildResult(rule, report, "集装箱货运量=" + fmt(containerFreight),
                "有集装箱车", "无集装箱车但有集装箱货运量");
        String[] fields = rule.getCheckField().split(",");
        if (fields.length < 2) return null;
        double volume = getH2032FieldValue(report, fields[0]);
        double vehicle = getH2032FieldValue(report, fields[1]);
        if (volume > 0 && vehicle == 0) {
            return buildResult(rule, report,
                h2032FieldLabel(fields[0]) + "=" + fmt(volume) + ", " + h2032FieldLabel(fields[1]) + "=0",
                "有" + h2032FieldLabel(fields[0]) + "应有对应车辆", "有" + h2032FieldLabel(fields[0]) + "但无" + h2032FieldLabel(fields[1]));
        }
        return null;
    }

    /** æ•´è½¦å¨ä½ä¸åœ¨(4,40]范围内核实 */
    private AuditResult checkOutRange(AuditRule rule, H2032EnterpriseMonthly report,
                                      Map<String, TransportAuthVehicle> authMap) {
        TransportAuthVehicle auth = findAuth(authMap, report.getEnterpriseName());
        if (auth == null) return null;
        if (num(auth.getOtherCount()) == 0) return null;

        double wholeTonnage = nvl(auth.getOtherTons()) / num(auth.getOtherCount());

        String[] range = rule.getThreshold().split(",");
        double min = Double.parseDouble(range[0]);
        double max = Double.parseDouble(range[1]);

        if (wholeTonnage < min || wholeTonnage > max) {
            return buildResult(rule, report, "整车吨位=" + fmt(wholeTonnage),
                fmt(min) + " â‰¤ æ•´è½¦å¨ä½ â‰¤ " + fmt(max), "超出范围");
    /** æ•°å€¼èŒƒå›´æ£€æŸ¥ï¼ˆå¦‚ æ•´è½¦å¨ä½ 4≤且≤40） */
    private AuditResult checkOutRange(AuditRule rule, H2032EnterpriseMonthly report) {
        String[] bounds = rule.getThreshold().split(",");
        if (bounds.length < 2) return null;
        double value = getH2032FieldValue(report, rule.getCheckField());
        double low = Double.parseDouble(bounds[0].trim());
        double high = Double.parseDouble(bounds[1].trim());
        if (value > 0 && (value < low || value > high)) {
            return buildResult(rule, report, h2032FieldLabel(rule.getCheckField()) + "=" + fmt(value),
                "范围 " + fmt(low) + "~" + fmt(high), "超出范围");
        }
        return null;
    }

    // ========== è¾…助方法 ==========

    private AuditResult buildResult(AuditRule rule, H2032EnterpriseMonthly report,
                                    String actual, String threshold, String deviation) {
@@ -291,6 +1703,10 @@
        return result;
    }

    private TransportAuthVehicle findAuth(Map<String, TransportAuthVehicle> authMap, String name) {
        return authMap.get(key(name));
    }

    private Map<String, TransportAuthVehicle> loadAuthMap(String reportPeriod) {
        Map<String, TransportAuthVehicle> map = new HashMap<>();
        List<TransportAuthVehicle> list = transportAuthMapper.selectList(
@@ -302,11 +1718,11 @@
        return map;
    }

    private Map<String, VehicleTrackMileage> loadTrackMap(String period) {
    private Map<String, VehicleTrackMileage> loadTrackMap(String reportPeriod) {
        Map<String, VehicleTrackMileage> map = new HashMap<>();
        List<VehicleTrackMileage> list = trackMileageMapper.selectList(
            new LambdaQueryWrapper<VehicleTrackMileage>()
                .eq(VehicleTrackMileage::getReportPeriod, period));
                .eq(VehicleTrackMileage::getReportPeriod, reportPeriod));
        for (VehicleTrackMileage v : list) {
            map.putIfAbsent(key(v.getEnterpriseName()), v);
        }
@@ -325,40 +1741,20 @@
        return map;
    }

    private TransportAuthVehicle findAuth(Map<String, TransportAuthVehicle> authMap, String name) {
        return authMap.get(key(name));
    private String getLastPeriod(String period) {
        String[] parts = period.split("-");
        int year = Integer.parseInt(parts[0]);
        int month = Integer.parseInt(parts[1]);
        if (month == 1) {
            year--;
            month = 12;
        } else {
            month--;
        }
        return year + "-" + (month < 10 ? "0" + month : String.valueOf(month));
    }

    private String key(String s) {
        return s == null ? "" : s.trim();
    }

    /** double æ˜¾ç¤ºæ ¼å¼åŒ–：避免科学计数法，整数值不带小数 */
    private String fmt(double v) {
        if (Double.isNaN(v) || Double.isInfinite(v)) return String.valueOf(v);
        if (v == Math.rint(v) && Math.abs(v) < 1e15) {
            return String.valueOf((long) v);
        }
        String s = String.format("%.6f", v);
        if (s.indexOf('.') >= 0) {
            s = s.replaceAll("0+$", "").replaceAll("\\.$", "");
        }
        return s;
    }

    private double nvl(Double v) {
        return v == null ? 0.0 : v;
    }

    private double nvl(Integer v) {
        return v == null ? 0.0 : v;
    }

    private int num(Integer v) {
        return v == null ? 0 : v;
    }

    private double getFieldValue(H2032EnterpriseMonthly report, String fieldName) {
    private double getH2032FieldValue(H2032EnterpriseMonthly report, String fieldName) {
        try {
            java.lang.reflect.Field field = H2032EnterpriseMonthly.class.getDeclaredField(fieldName);
            field.setAccessible(true);
@@ -372,16 +1768,257 @@
        }
    }

    private String getLastPeriod(String period) {
        String[] parts = period.split("-");
        int year = Integer.parseInt(parts[0]);
        int month = Integer.parseInt(parts[1]);
        if (month == 1) {
            year--;
            month = 12;
        } else {
            month--;
    private String h2032FieldLabel(String field) {
        String label = FREIGHT_TYPE_NAMES.get(field);
        if (label != null) return label;
        java.util.Map<String, String> labels = new HashMap<>();
        labels.put("vehicleTotal", "车辆数");
        labels.put("tonsTotal", "总吨位");
        labels.put("vehicleContainer", "集装箱车辆数");
        labels.put("tonsWhole", "整车吨位");
        labels.put("turnoverTotal", "周转量");
        labels.put("vehicleWhole", "整车车辆数");
        String v = labels.get(field);
        return v == null ? field : v;
        }
        return String.format("%d-%02d", year, month);

    private boolean nearlyEqual(double a, double b) {
        if (a == b) return true;
        return Math.abs(a - b) <= 1e-6 * Math.max(1.0, Math.max(Math.abs(a), Math.abs(b)));
    }

    private String key(String s) {
        if (s == null) return "";
        return s.trim().replaceAll("\\s+", "");
    }

    private double nvl(Double v) {
        return v == null ? 0.0 : v;
    }

    private double num(Integer v) {
        return v == null ? 0.0 : v.doubleValue();
    }

    private String fmt(double v) {
        if (v == Math.floor(v) && !Double.isInfinite(v)) {
            return String.valueOf((long) v);
        }
        return String.valueOf(Math.round(v * 100.0) / 100.0);
    }

    /** å æ¯”/小数值：保留 4 ä½å°æ•° */
    private String fmt4(double v) {
        if (v == Math.floor(v) && !Double.isInfinite(v)) {
            return String.valueOf((long) v);
        }
        return String.valueOf(Math.round(v * 10000.0) / 10000.0);
    }

    // ========== H2031 æ—…客审核 ==========

    private AuditResult checkPassengerRule(AuditRule rule, PassengerEnterpriseMonthly report,
                                           Map<String, PassengerAuthVehicle> authMap,
                                           Map<String, PassengerEnterpriseMonthly> lastMonthMap) {
        try {
            switch (rule.getCompareType()) {
                case "DIFF":
                    return checkPassengerDiff(rule, report, authMap);
                case "MOM_EQ_ZERO":
                    return checkPassengerMomEqZero(rule, report, lastMonthMap);
                case "MOM_PCT":
                    return checkPassengerMomPct(rule, report, lastMonthMap);
                case "MOM_EQ":
                    return checkPassengerMomEq(rule, report, lastMonthMap);
                case "EXISTENCE":
                    return checkPassengerExistence(rule, report);
                default:
                    return null;
            }
        } catch (Exception e) {
            log.error("Passenger rule check error: {} - {}", rule.getRuleCode(), e.getMessage());
            return null;
        }
    }

    /** è½¦è¾†æ•°/载客位数 ä¸Žè¿æ”¿å¯¹æ¯”，差距超阈值核实 */
    private AuditResult checkPassengerDiff(AuditRule rule, PassengerEnterpriseMonthly report,
                                           Map<String, PassengerAuthVehicle> authMap) {
        PassengerAuthVehicle auth = authMap.get(key(report.getEnterpriseName()));
        if (auth == null) return null;
        double actual;
        double reference;
        if (rule.getCheckField().contains("seat")) {
            actual = num(report.getSeatTotal());
            reference = num(auth.getSeatCount());
        } else {
            actual = num(report.getVehicleTotal());
            reference = num(auth.getVehicleCount());
        }
        double threshold = Double.parseDouble(rule.getThreshold());
        double diff = Math.abs(actual - reference);
        if (diff > threshold) {
            return buildPassengerResult(rule, report, "上报=" + fmt(actual) + ", è¿æ”¿=" + fmt(reference),
                "差距≤" + fmt(threshold), "差距=" + fmt(diff));
        }
        return null;
    }

    /** çŽ¯æ¯”上个月等于0：值与上月相同需核实（上月为0不核实） */
    private AuditResult checkPassengerMomEqZero(AuditRule rule, PassengerEnterpriseMonthly report,
                                                Map<String, PassengerEnterpriseMonthly> lastMonthMap) {
        PassengerEnterpriseMonthly lastMonth = lastMonthMap.get(key(report.getEnterpriseCode()));
        if (lastMonth == null) return null;
        List<String> hits = new ArrayList<>();
        for (String field : rule.getCheckField().split(",")) {
            double current = getPassengerFieldValue(report, field);
            double last = getPassengerFieldValue(lastMonth, field);
            if (last > 0 && nearlyEqual(current, last)) {
                hits.add(fieldLabel(field) + "=" + fmt(current));
            }
        }
        if (!hits.isEmpty()) {
            return buildPassengerResult(rule, report, "本月与上月相同: " + String.join("、", hits),
                "环比≠0", "环比=0");
        }
        return null;
    }

    /** å¹³å‡è¿è·çŽ¯æ¯”超 Â±threshold% æ ¸å®ž */
    private AuditResult checkPassengerMomPct(AuditRule rule, PassengerEnterpriseMonthly report,
                                             Map<String, PassengerEnterpriseMonthly> lastMonthMap) {
        PassengerEnterpriseMonthly lastMonth = lastMonthMap.get(key(report.getEnterpriseCode()));
        if (lastMonth == null) return null;
        double threshold = Double.parseDouble(rule.getThreshold());
        List<String> hits = new ArrayList<>();
        for (String field : rule.getCheckField().split(",")) {
            double current = getPassengerFieldValue(report, field);
            double last = getPassengerFieldValue(lastMonth, field);
            if (last > 0) {
                double pct = Math.abs((current - last) / last) * 100.0;
                if (pct > threshold) {
                    hits.add(fieldLabel(field) + "=" + fmt(current) + "，上月=" + fmt(last) + "，环比" + fmt(pct) + "%");
                }
            }
        }
        if (!hits.isEmpty()) {
            return buildPassengerResult(rule, report, String.join("；", hits),
                "环比≤±" + fmt(threshold) + "%", "环比超限");
        }
        return null;
    }

    /** åŒ…车平均运距等于上月核实 */
    private AuditResult checkPassengerMomEq(AuditRule rule, PassengerEnterpriseMonthly report,
                                            Map<String, PassengerEnterpriseMonthly> lastMonthMap) {
        PassengerEnterpriseMonthly lastMonth = lastMonthMap.get(key(report.getEnterpriseCode()));
        if (lastMonth == null) return null;
        List<String> hits = new ArrayList<>();
        for (String field : rule.getCheckField().split(",")) {
            double current = getPassengerFieldValue(report, field);
            double last = getPassengerFieldValue(lastMonth, field);
            if (last > 0 && nearlyEqual(current, last)) {
                hits.add(fieldLabel(field) + "=" + fmt(current));
            }
        }
        if (!hits.isEmpty()) {
            return buildPassengerResult(rule, report, "等于上月: " + String.join("、", hits),
                "与上月不同", "与上月相同");
        }
        return null;
    }

    /** æ— ç­çº¿/无包车却有对应客运量：check_field é¦–个为车辆字段，其余为客运量字段 */
    private AuditResult checkPassengerExistence(AuditRule rule, PassengerEnterpriseMonthly report) {
        String[] fields = rule.getCheckField().split(",");
        if (fields.length < 2) return null;
        String vehicleField = fields[0];
        double vehicleCount = getPassengerFieldValue(report, vehicleField);
        if (vehicleCount > 0) return null;
        List<String> hits = new ArrayList<>();
        for (int i = 1; i < fields.length; i++) {
            double value = getPassengerFieldValue(report, fields[i]);
            if (value > 0) {
                hits.add(fieldLabel(fields[i]) + "=" + fmt(value));
            }
        }
        if (!hits.isEmpty()) {
            String label = "schedule".equals(vehicleField) || "vehicleSchedule".equals(vehicleField) ? "班线" : "包车";
            return buildPassengerResult(rule, report, String.join("、", hits),
                "有" + label + "车辆", "无" + label + "车辆但有客运量");
        }
        return null;
    }

    private Map<String, PassengerAuthVehicle> loadPassengerAuthMap(String reportPeriod) {
        Map<String, PassengerAuthVehicle> map = new HashMap<>();
        List<PassengerAuthVehicle> list = passengerAuthMapper.selectList(
            new LambdaQueryWrapper<PassengerAuthVehicle>()
                .eq(PassengerAuthVehicle::getReportPeriod, reportPeriod));
        for (PassengerAuthVehicle v : list) {
            map.putIfAbsent(key(v.getEnterpriseName()), v);
        }
        return map;
    }

    private Map<String, PassengerEnterpriseMonthly> loadPassengerLastMonthMap(String period) {
        Map<String, PassengerEnterpriseMonthly> map = new HashMap<>();
        String lastPeriod = getLastPeriod(period);
        List<PassengerEnterpriseMonthly> list = passengerMapper.selectList(
            new LambdaQueryWrapper<PassengerEnterpriseMonthly>()
                .eq(PassengerEnterpriseMonthly::getReportPeriod, lastPeriod));
        for (PassengerEnterpriseMonthly v : list) {
            map.putIfAbsent(key(v.getEnterpriseCode()), v);
        }
        return map;
    }

    private double getPassengerFieldValue(PassengerEnterpriseMonthly report, String fieldName) {
        try {
            java.lang.reflect.Field field = PassengerEnterpriseMonthly.class.getDeclaredField(fieldName);
            field.setAccessible(true);
            Object value = field.get(report);
            if (value == null) return 0.0;
            if (value instanceof Double) return (Double) value;
            if (value instanceof Integer) return ((Integer) value).doubleValue();
            return Double.parseDouble(value.toString());
        } catch (Exception e) {
            return 0.0;
        }
    }

    private String fieldLabel(String field) {
        java.util.Map<String, String> labels = new HashMap<>();
        labels.put("passengerClass1", "一类班线客运量");
        labels.put("passengerClass2", "二类班线客运量");
        labels.put("passengerClass3", "三类班线客运量");
        labels.put("passengerClass4", "四类班线客运量");
        labels.put("passengerCharter", "包车客运量");
        labels.put("turnoverClass1", "一类班线周转量");
        labels.put("turnoverClass2", "二类班线周转量");
        labels.put("turnoverClass3", "三类班线周转量");
        labels.put("turnoverClass4", "四类班线周转量");
        labels.put("turnoverCharter", "包车周转量");
        labels.put("avgDistanceClass1", "一类班线平均运距");
        labels.put("avgDistanceClass2", "二类班线平均运距");
        labels.put("avgDistanceClass3", "三类班线平均运距");
        labels.put("avgDistanceClass4", "四类班线平均运距");
        labels.put("avgDistanceCharter", "包车平均运距");
        String label = labels.get(field);
        return label == null ? field : label;
    }

    private AuditResult buildPassengerResult(AuditRule rule, PassengerEnterpriseMonthly report,
                                             String actual, String threshold, String deviation) {
        AuditResult result = new AuditResult();
        result.setRuleId(rule.getId());
        result.setReportId(report.getId());
        result.setEnterpriseCode(report.getEnterpriseCode());
        result.setReportPeriod(report.getReportPeriod());
        result.setActualValue(actual);
        result.setThresholdValue(threshold);
        result.setDeviation(deviation);
        result.setStatus("PENDING");
        return result;
    }
}

 traffic-audit-server/src/main/java/com/trafficaudit/common/GlobalExceptionHandler.java

New file
@@ -0,0 +1,22 @@
package com.trafficaudit.common;

import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

/** å…¨å±€å¼‚常处理：把 500 é”™è¯¯åŽŸå› é€å‡ºåˆ°å‰ç«¯æç¤ºï¼ˆP0：导出失败可见具体原因） */
@Slf4j
@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(Exception.class)
    public ResponseEntity<Result<String>> handle(Exception e) {
        log.error("Unhandled exception", e);
        String msg = e.getMessage();
        if (msg == null || msg.trim().isEmpty()) msg = e.toString();
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
            .body(Result.error(500, msg));
    }
}

 traffic-audit-server/src/main/java/com/trafficaudit/common/util/RegionUtil.java

@@ -44,6 +44,7 @@

        ALIAS_MAP.put("恩施", "恩施州");
        ALIAS_MAP.put("恩施市", "恩施州");
        ALIAS_MAP.put("恩施土家族苗族自治州", "恩施州");
        ALIAS_MAP.put("天门", "天门市");
        ALIAS_MAP.put("林区", "神农架林区");
        ALIAS_MAP.put("神农架", "神农架林区");

 traffic-audit-server/src/main/java/com/trafficaudit/config/TemplateDownloadController.java

New file
@@ -0,0 +1,64 @@
package com.trafficaudit.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.io.FileSystemResource;
import org.springframework.core.io.Resource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.io.File;
import java.io.IOException;
import java.net.URLEncoder;

/**
 * æ•°æ®å¯¼å…¥é¡µã€Œä¸‹è½½æ¨¡æ¿ã€ï¼š/api/templates/** -> docs ç›®å½•ä¸‹çš„模板文件。
 * ç”¨ Controller è€Œéžé™æ€èµ„源映射，便于设置中文文件名的下载头并防路径穿越。
 */
@RestController
@RequestMapping("/api/templates")
public class TemplateDownloadController {

    @Value("${docs.template-root:docs}")
    private String templateRoot;

    @GetMapping("/{*path}")
    public ResponseEntity<Resource> download(@PathVariable String path) throws IOException {
        File file = resolveTemplateFile(path);
        if (file == null) {
            return ResponseEntity.notFound().build();
        }
        String encoded = URLEncoder.encode(file.getName(), "UTF-8").replace("+", "%20");
        return ResponseEntity.ok()
            .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename*=UTF-8''" + encoded)
            .contentType(MediaType.APPLICATION_OCTET_STREAM)
            .contentLength(file.length())
            .body(new FileSystemResource(file));
    }

    /** æ¨¡æ¿å®šä½ï¼šé…ç½®ç›®å½• â†’ user.dir â†’ user.dir/.. é€çº§å›žé€€ï¼ˆä¸ŽæŠ¥è¡¨æ¨¡å—一致），并防路径穿越 */
    private File resolveTemplateFile(String rel) throws IOException {
        String r = rel;
        while (r.startsWith("./")) r = r.substring(2);
        if (r.contains("..")) {
            return null;
        }
        String[] roots = {
            templateRoot,
            System.getProperty("user.dir") + "/" + templateRoot,
            System.getProperty("user.dir") + "/../" + templateRoot
        };
        for (String root : roots) {
            if (root == null || root.trim().isEmpty()) continue;
            File f = new File(root, r);
            if (f.exists() && f.isFile()) {
                return f.getCanonicalFile();
            }
        }
        return null;
    }
}

 traffic-audit-server/src/main/java/com/trafficaudit/dataimport/controller/DataImportController.java

@@ -2,8 +2,12 @@

import com.trafficaudit.common.Result;
import com.trafficaudit.dataimport.dto.ImportResult;
import com.trafficaudit.dataimport.entity.ImportBatch;
import com.trafficaudit.dataimport.mapper.ImportBatchMapper;
import com.trafficaudit.dataimport.service.DataImportService;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
@@ -11,6 +15,9 @@
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

@Slf4j
@RestController
@@ -19,6 +26,8 @@

    @Resource
    private DataImportService importService;
    @Resource
    private ImportBatchMapper importBatchMapper;

    /** H203-2表 é“路货物运输月度生产情况 */
    @PostMapping("/h2032")
@@ -50,6 +59,239 @@
    }



    /** H204 é“路货运车辆能源消耗情况（季度能耗明细 + è¿æ”¿è½¦è¾†ä¿¡æ¯ï¼‰ */
    @PostMapping("/energyMonthly")
    public Result<String> importEnergyMonthly(@RequestParam("file") MultipartFile file,
                                              @RequestParam("period") String period) {
        try {
            ImportResult result = importService.importEnergyMonthly(file, period);
            String msg = "H204能耗季报导入完成：成功 " + result.getSuccess() + " æ¡ï¼Œå¤±è´¥ " + result.getFail() + " æ¡ï¼ˆå«åŒæŠ¥è¡¨æœŸè¿æ”¿è½¦è¾†ä¿¡æ¯ï¼‰";
            if (result.getFail() > 0) {
                java.util.List<String> details = result.getFailDetails();
                int shown = Math.min(details.size(), 100);
                for (int i = 0; i < shown; i++) {
                    msg += "\n" + details.get(i);
                }
                if (details.size() > shown) {
                    msg += "\n……共 " + details.size() + " è¡Œå¤±è´¥";
                }
            }
            return Result.ok(msg);
        } catch (Exception e) {
            log.error("energyMonthly import error", e);
            return Result.error("导入失败: " + e.getMessage());
        }
    }

    /** èƒ½è€—车辆运政信息（独立模板，也可随 H204 å­£æŠ¥ç¬¬äºŒä¸ª sheet ä¸€å¹¶å¯¼å…¥ï¼‰ */
    @PostMapping("/energyAuth")
    public Result<String> importEnergyAuth(@RequestParam("file") MultipartFile file,
                                           @RequestParam("period") String period) {
        try {
            ImportResult result = importService.importEnergyAuth(file, period);
            String msg = "能耗车辆运政信息导入完成：成功 " + result.getSuccess() + " æ¡ï¼Œå¤±è´¥ " + result.getFail() + " æ¡";
            if (result.getFail() > 0) {
                java.util.List<String> details = result.getFailDetails();
                int shown = Math.min(details.size(), 100);
                for (int i = 0; i < shown; i++) {
                    msg += "\n" + details.get(i);
                }
                if (details.size() > shown) {
                    msg += "\n……共 " + details.size() + " è¡Œå¤±è´¥";
                }
            }
            return Result.ok(msg);
        } catch (Exception e) {
            log.error("energyAuth import error", e);
            return Result.error("导入失败: " + e.getMessage());
        }
    }

    /** H203-1表 å…¬è·¯æ—…客运输月度生产情况（含运政车辆数sheet） */
    @PostMapping("/passengerMonthly")
    public Result<String> importPassengerMonthly(@RequestParam("file") MultipartFile file,
                                                 @RequestParam("period") String period) {
        try {
            ImportResult result = importService.importPassengerMonthly(file, period);
            String msg = "H2031旅客月报导入完成：成功 " + result.getSuccess() + " æ¡ï¼Œå¤±è´¥ " + result.getFail() + " æ¡ï¼ˆå«åŒæŠ¥è¡¨æœŸè¿æ”¿è½¦è¾†æ•°æ®ï¼‰";
            if (result.getFail() > 0) {
                java.util.List<String> details = result.getFailDetails();
                int shown = Math.min(details.size(), 100);
                for (int i = 0; i < shown; i++) {
                    msg += "\n" + details.get(i);
                }
                if (details.size() > shown) {
                    msg += "\n……共 " + details.size() + " è¡Œå¤±è´¥";
                }
            }
            return Result.ok(msg);
        } catch (Exception e) {
            log.error("passengerMonthly import error", e);
            return Result.error("导入失败: " + e.getMessage());
        }
    }


    /** å…¬è·¯æ—…客个体客运量/周转量（企业线下汇报，导入后供分市州表个体行填充） */
    @PostMapping("/passengerIndividual")
    public Result<String> importPassengerIndividual(@RequestParam("file") MultipartFile file,
                                                    @RequestParam("period") String period) {
        try {
            ImportResult result = importService.importPassengerIndividual(file, period);
            String msg = "个体客运量导入完成：成功 " + result.getSuccess() + " æ¡ï¼Œå¤±è´¥ " + result.getFail() + " æ¡";
            if (result.getFail() > 0) {
                java.util.List<String> details = result.getFailDetails();
                int shown = Math.min(details.size(), 100);
                for (int i = 0; i < shown; i++) {
                    msg += "\n" + details.get(i);
                }
                if (details.size() > shown) {
                    msg += "\n……共 " + details.size() + " è¡Œå¤±è´¥";
                }
            }
            return Result.ok(msg);
        } catch (Exception e) {
            log.error("passengerIndividual import error", e);
            return Result.error("导入失败: " + e.getMessage());
        }
    }

    /** å…¬è·¯æ—…客运政车辆数（独立模板，也可随 H203-1 æœˆæŠ¥ç¬¬äºŒä¸ª sheet ä¸€å¹¶å¯¼å…¥ï¼‰ */
    @PostMapping("/passengerAuth")
    public Result<String> importPassengerAuth(@RequestParam("file") MultipartFile file,
                                              @RequestParam("period") String period) {
        try {
            ImportResult result = importService.importPassengerAuth(file, period);
            String msg = "旅客运政车辆数导入完成：成功 " + result.getSuccess() + " æ¡ï¼Œå¤±è´¥ " + result.getFail() + " æ¡";
            if (result.getFail() > 0) {
                java.util.List<String> details = result.getFailDetails();
                int shown = Math.min(details.size(), 100);
                for (int i = 0; i < shown; i++) {
                    msg += "\n" + details.get(i);
                }
                if (details.size() > shown) {
                    msg += "\n……共 " + details.size() + " è¡Œå¤±è´¥";
                }
            }
            return Result.ok(msg);
        } catch (Exception e) {
            log.error("passengerAuth import error", e);
            return Result.error("导入失败: " + e.getMessage());
        }
    }

    /** åŸŽå¸‚公交月报（城市公共交通月度运营情况，企业级明细） */
    @PostMapping("/cityBus")
    public Result<String> importCityBus(@RequestParam("file") MultipartFile file,
                                        @RequestParam("period") String period) {
        try {
            ImportResult result = importService.importCityBus(file, period);
            String msg = "城市公交月报导入完成：成功 " + result.getSuccess() + " æ¡ï¼Œå¤±è´¥ " + result.getFail() + " æ¡";
            if (result.getFail() > 0) {
                java.util.List<String> details = result.getFailDetails();
                int shown = Math.min(details.size(), 100);
                for (int i = 0; i < shown; i++) {
                    msg += "\n" + details.get(i);
                }
                if (details.size() > shown) {
                    msg += "\n……共 " + details.size() + " è¡Œå¤±è´¥";
                }
            }
            return Result.ok(msg);
        } catch (Exception e) {
            log.error("cityBus import error", e);
            return Result.error("导入失败: " + e.getMessage());
        }
    }

    /** å·¡æ¸¸å‡ºç§Ÿæ±½è½¦è¿è¥æœåŠ¡æƒ…况月报（市州级） */
    @PostMapping("/cityTaxi")
    public Result<String> importCityTaxi(@RequestParam("file") MultipartFile file,
                                         @RequestParam("period") String period) {
        try {
            ImportResult result = importService.importCityTaxi(file, period);
            String msg = "巡游出租月报导入完成：成功 " + result.getSuccess() + " æ¡ï¼Œå¤±è´¥ " + result.getFail() + " æ¡";
            if (result.getFail() > 0) {
                java.util.List<String> details = result.getFailDetails();
                int shown = Math.min(details.size(), 100);
                for (int i = 0; i < shown; i++) {
                    msg += "\n" + details.get(i);
                }
                if (details.size() > shown) {
                    msg += "\n……共 " + details.size() + " è¡Œå¤±è´¥";
                }
            }
            return Result.ok(msg);
        } catch (Exception e) {
            log.error("cityTaxi import error", e);
            return Result.error("导入失败: " + e.getMessage());
        }
    }

    /** å‡ºç§Ÿè½¦è¿æ”¿è½¦è¾†ä¿¡æ¯ï¼ˆè½¦è¾†çº§æ˜Žç»†ï¼Œç”¨äºŽè¿è¥è½¦æ•°å¯¹æ¯”） */
    @PostMapping("/cityTaxiAuth")
    public Result<String> importCityTaxiAuth(@RequestParam("file") MultipartFile file,
                                             @RequestParam("period") String period) {
        try {
            int count = importService.importCityTaxiAuth(file, period);
            return Result.ok("出租车运政车辆导入成功, å…± " + count + " æ¡è®°å½•");
        } catch (Exception e) {
            log.error("cityTaxiAuth import error", e);
            return Result.error("导入失败: " + e.getMessage());
        }
    }

    /** æŠ•èµ„月报（全省汇总大表）：category=客运站场/物流园区 */
    @PostMapping("/investment")
    public Result<String> importInvestment(@RequestParam("file") MultipartFile file,
                                           @RequestParam("period") String period,
                                           @RequestParam(value = "category", defaultValue = "客运站场") String category) {
        try {
            ImportResult result = importService.importInvestment(file, period, category);
            String msg = "投资月报导入完成（" + category + "）：成功 " + result.getSuccess() + " æ¡ï¼Œå¤±è´¥ " + result.getFail() + " æ¡";
            if (result.getFail() > 0) {
                java.util.List<String> details = result.getFailDetails();
                int shown = Math.min(details.size(), 100);
                for (int i = 0; i < shown; i++) {
                    msg += "\n" + details.get(i);
                }
                if (details.size() > shown) {
                    msg += "\n……共 " + details.size() + " è¡Œå¤±è´¥";
                }
            }
            return Result.ok(msg);
        } catch (Exception e) {
            log.error("investment import error", e);
            return Result.error("导入失败: " + e.getMessage());
        }
    }

    /** æŠ•èµ„市州单表批量导入（M2）：扫描 docs/投资/输入/{类别}/{X月} ç›®å½•å…¨éƒ¨å¸‚州报表，category=客运站场/物流园区 */
    @PostMapping("/investCityBatch")
    public Result<Object> importInvestCityBatch(@RequestParam("period") String period,
                                                @RequestParam(value = "category", defaultValue = "客运站场") String category) {
        try {
            Map<String, Object> result = importService.importInvestCityDir(period, category);
            return Result.ok(result);
        } catch (Exception e) {
            log.error("investCityBatch import error", e);
            return Result.error("导入失败: " + e.getMessage());
        }
    }

    /** æŠ•èµ„系统导出（审核比对基准） */
    @PostMapping("/investmentSystem")
    public Result<String> importInvestmentSystem(@RequestParam("file") MultipartFile file,
                                                 @RequestParam("period") String period) {
        try {
            int count = importService.importInvestmentSystem(file, period);
            return Result.ok("投资系统导出导入成功, å…± " + count + " æ¡è®°å½•");
        } catch (Exception e) {
            log.error("investmentSystem import error", e);
            return Result.error("导入失败: " + e.getMessage());
        }
    }
    /** è¿æ”¿è½¦è¾† */
    @PostMapping("/transportAuth")
    public Result<String> importTransportAuth(@RequestParam("file") MultipartFile file,
@@ -101,4 +343,63 @@
            return Result.error("导入失败: " + e.getMessage());
        }
    }
    /** ç›®å½•æµè§ˆå™¨ï¼špath ä¸ºç©ºè¿”回项目 docs æ•°æ®ç›®å½•ï¼Œè¿”回子目录与当前目录 Excel æ–‡ä»¶ */
    @GetMapping("/dirs")
    public Result<Map<String, Object>> dirs(@RequestParam(value = "path", required = false) String path) {
        try {
            Map<String, Object> result = importService.listDirs(path);
            return Result.ok(result);
        } catch (Exception e) {
            log.error("list dirs error", e);
            return Result.error("目录浏览失败: " + e.getMessage());
        }
    }

    /** æŒ‰è·¯å¾„导入单个 Excel æ–‡ä»¶ï¼ˆå‰ç«¯é€æ–‡ä»¶å¯¼å…¥æ˜¾ç¤ºè¿›åº¦ï¼‰ï¼›æŠ¥è¡¨æœŸä¼˜å…ˆä»Žæ–‡ä»¶åè¯†åˆ« */
    @PostMapping("/fromDirFile")
    public Result<Map<String, Object>> importFromDirFile(@RequestParam("type") String type,
                                                         @RequestParam(value = "period", required = false) String period,
                                                         @RequestParam(value = "skipImported", defaultValue = "true") boolean skipImported,
                                                         @RequestParam("path") String path) {
        try {
            Map<String, Object> result = importService.importDirFileByPath(type, period, skipImported, path);
            return Result.ok(result);
        } catch (Exception e) {
            log.error("fromDirFile import error", e);
            return Result.error("导入失败: " + e.getMessage());
        }
    }

    /** ä»ŽæœåŠ¡ç«¯æ–‡ä»¶å¤¹æ‰¹é‡å¯¼å…¥ï¼šæ‰«æ dir ä¸‹å…¨éƒ¨ .xlsx/.xls，按 type é€ä¸ªå¯¼å…¥ï¼›æŠ¥è¡¨æœŸä¼˜å…ˆä»Žæ–‡ä»¶åè¯†åˆ« */
    @PostMapping("/fromDir")
    public Result<Object> importFromDir(@RequestParam("type") String type,
                                        @RequestParam(value = "period", required = false) String period,
                                        @RequestParam(value = "skipImported", defaultValue = "true") boolean skipImported,
                                        @RequestParam("dir") String dir) {
        try {
            Map<String, Object> result = importService.importFromDir(type, period, skipImported, dir);
            return Result.ok(result);
        } catch (Exception e) {
            log.error("fromDir import error", e);
            return Result.error("导入失败: " + e.getMessage());
        }
    }

    /** å¯¼å…¥æ‰¹æ¬¡åŽ†å²ï¼ˆæ•°æ®å¯¼å…¥é¡µå±•ç¤ºæœ€è¿‘导入结果） */
    @GetMapping("/batches")
    public Result<Map<String, Object>> batches(@RequestParam(value = "type", required = false) String type,
                                               @RequestParam(value = "period", required = false) String period,
                                               @RequestParam(value = "limit", defaultValue = "20") int limit) {
        int safeLimit = Math.min(Math.max(limit, 1), 200);
        LambdaQueryWrapper<ImportBatch> w = new LambdaQueryWrapper<ImportBatch>()
            .eq(type != null && !type.trim().isEmpty(), ImportBatch::getImportType, type)
            .eq(period != null && !period.trim().isEmpty(), ImportBatch::getReportPeriod, period)
            .orderByDesc(ImportBatch::getId)
            .last("limit " + safeLimit);
        List<ImportBatch> list = importBatchMapper.selectList(w);
        Map<String, Object> result = new LinkedHashMap<>();
        result.put("records", list);
        return Result.ok(result);
    }

}

 traffic-audit-server/src/main/java/com/trafficaudit/dataimport/controller/DataViewController.java

@@ -6,11 +6,21 @@
import com.trafficaudit.common.Result;
import com.trafficaudit.dataimport.entity.FreightTurnoverImport;
import com.trafficaudit.dataimport.entity.H2032EnterpriseMonthly;
import com.trafficaudit.dataimport.entity.PassengerAuthVehicle;
import com.trafficaudit.dataimport.entity.CityBusMonthly;
import com.trafficaudit.dataimport.entity.CityTaxiAuth;
import com.trafficaudit.dataimport.entity.CityTaxiMonthly;
import com.trafficaudit.dataimport.entity.PassengerEnterpriseMonthly;
import com.trafficaudit.dataimport.entity.ScaleSplitTransport;
import com.trafficaudit.dataimport.entity.TransportAuthVehicle;
import com.trafficaudit.dataimport.entity.VehicleTrackMileage;
import com.trafficaudit.dataimport.mapper.FreightTurnoverImportMapper;
import com.trafficaudit.dataimport.mapper.H2032EnterpriseMonthlyMapper;
import com.trafficaudit.dataimport.mapper.PassengerAuthVehicleMapper;
import com.trafficaudit.dataimport.mapper.CityBusMonthlyMapper;
import com.trafficaudit.dataimport.mapper.CityTaxiAuthMapper;
import com.trafficaudit.dataimport.mapper.CityTaxiMonthlyMapper;
import com.trafficaudit.dataimport.mapper.PassengerEnterpriseMonthlyMapper;
import com.trafficaudit.dataimport.mapper.ScaleSplitTransportMapper;
import com.trafficaudit.dataimport.mapper.TransportAuthVehicleMapper;
import com.trafficaudit.dataimport.mapper.VehicleTrackMileageMapper;
@@ -44,6 +54,16 @@
    private ScaleSplitTransportMapper scaleSplitMapper;
    @Resource
    private FreightTurnoverImportMapper freightTurnoverMapper;
    @Resource
    private PassengerEnterpriseMonthlyMapper passengerMapper;
    @Resource
    private PassengerAuthVehicleMapper passengerAuthMapper;
    @Resource
    private CityBusMonthlyMapper cityBusMapper;
    @Resource
    private CityTaxiMonthlyMapper cityTaxiMapper;
    @Resource
    private CityTaxiAuthMapper cityTaxiAuthMapper;

    @GetMapping("/list")
    public Result<Map<String, Object>> list(@RequestParam("type") String type,
@@ -113,6 +133,61 @@
                fillPage(result, r);
                break;
            }
            case "h2031": {
                LambdaQueryWrapper<PassengerEnterpriseMonthly> w = new LambdaQueryWrapper<PassengerEnterpriseMonthly>()
                        .eq(notEmpty(period), PassengerEnterpriseMonthly::getReportPeriod, period)
                        .like(!kw.isEmpty(), PassengerEnterpriseMonthly::getEnterpriseName, kw)
                        .orderByDesc(PassengerEnterpriseMonthly::getId);
                Page<PassengerEnterpriseMonthly> p = new Page<>(safePage, safeSize);
                Page<PassengerEnterpriseMonthly> r = passengerMapper.selectPage(p, w);
                result.put("records", toMaps(r.getRecords(), propsOf(H2031_COLUMNS)));
                fillPage(result, r);
                break;
            }
            case "cityBus": {
                LambdaQueryWrapper<CityBusMonthly> w = new LambdaQueryWrapper<CityBusMonthly>()
                        .eq(notEmpty(period), CityBusMonthly::getReportPeriod, period)
                        .like(!kw.isEmpty(), CityBusMonthly::getEnterpriseName, kw)
                        .orderByDesc(CityBusMonthly::getId);
                Page<CityBusMonthly> p = new Page<>(safePage, safeSize);
                Page<CityBusMonthly> r = cityBusMapper.selectPage(p, w);
                result.put("records", toMaps(r.getRecords(), propsOf(BUS_COLUMNS)));
                fillPage(result, r);
                break;
            }
            case "cityTaxi": {
                LambdaQueryWrapper<CityTaxiMonthly> w = new LambdaQueryWrapper<CityTaxiMonthly>()
                        .eq(notEmpty(period), CityTaxiMonthly::getReportPeriod, period)
                        .like(!kw.isEmpty(), CityTaxiMonthly::getCity, kw)
                        .orderByAsc(CityTaxiMonthly::getId);
                Page<CityTaxiMonthly> p = new Page<>(safePage, safeSize);
                Page<CityTaxiMonthly> r = cityTaxiMapper.selectPage(p, w);
                result.put("records", toMaps(r.getRecords(), propsOf(TAXI_COLUMNS)));
                fillPage(result, r);
                break;
            }
            case "cityTaxiAuth": {
                LambdaQueryWrapper<CityTaxiAuth> w = new LambdaQueryWrapper<CityTaxiAuth>()
                        .eq(notEmpty(period), CityTaxiAuth::getReportPeriod, period)
                        .like(!kw.isEmpty(), CityTaxiAuth::getCity, kw)
                        .orderByDesc(CityTaxiAuth::getId);
                Page<CityTaxiAuth> p = new Page<>(safePage, safeSize);
                Page<CityTaxiAuth> r = cityTaxiAuthMapper.selectPage(p, w);
                result.put("records", toMaps(r.getRecords(), propsOf(TAXI_AUTH_COLUMNS)));
                fillPage(result, r);
                break;
            }
            case "passengerAuth": {
                LambdaQueryWrapper<PassengerAuthVehicle> w = new LambdaQueryWrapper<PassengerAuthVehicle>()
                        .eq(notEmpty(period), PassengerAuthVehicle::getReportPeriod, period)
                        .like(!kw.isEmpty(), PassengerAuthVehicle::getEnterpriseName, kw)
                        .orderByDesc(PassengerAuthVehicle::getId);
                Page<PassengerAuthVehicle> p = new Page<>(safePage, safeSize);
                Page<PassengerAuthVehicle> r = passengerAuthMapper.selectPage(p, w);
                result.put("records", toMaps(r.getRecords(), propsOf(PAUTH_COLUMNS)));
                fillPage(result, r);
                break;
            }
            case "freightTurnover": {
                LambdaQueryWrapper<FreightTurnoverImport> w = new LambdaQueryWrapper<FreightTurnoverImport>()
                        .eq(notEmpty(period), FreightTurnoverImport::getReportPeriod, period)
@@ -171,6 +246,11 @@
            case "trackMileage": return TRACK_COLUMNS;
            case "scaleSplit": return SPLIT_COLUMNS;
            case "freightTurnover": return FREIGHT_COLUMNS;
            case "h2031": return H2031_COLUMNS;
            case "cityBus": return BUS_COLUMNS;
            case "cityTaxi": return TAXI_COLUMNS;
            case "cityTaxiAuth": return TAXI_AUTH_COLUMNS;
            case "passengerAuth": return PAUTH_COLUMNS;
            default: return new ArrayList<>();
        }
    }
@@ -181,6 +261,7 @@
        m.put("label", label);
        m.put("width", width);
        return m;

    }

    private static final List<Map<String, Object>> H2032_COLUMNS = new ArrayList<>();
@@ -188,6 +269,11 @@
    private static final List<Map<String, Object>> TRACK_COLUMNS = new ArrayList<>();
    private static final List<Map<String, Object>> SPLIT_COLUMNS = new ArrayList<>();
    private static final List<Map<String, Object>> FREIGHT_COLUMNS = new ArrayList<>();
    private static final List<Map<String, Object>> H2031_COLUMNS = new ArrayList<>();
    private static final List<Map<String, Object>> PAUTH_COLUMNS = new ArrayList<>();
    private static final List<Map<String, Object>> BUS_COLUMNS = new ArrayList<>();
    private static final List<Map<String, Object>> TAXI_COLUMNS = new ArrayList<>();
    private static final List<Map<String, Object>> TAXI_AUTH_COLUMNS = new ArrayList<>();

    static {
        H2032_COLUMNS.add(col("reportPeriod", "报表期", 100));
@@ -268,5 +354,96 @@
        for (int m = 1; m <= 12; m++) {
            FREIGHT_COLUMNS.add(col(String.format("lastTurnoverM%02d", m), "去年周转量" + m + "月", 140));
        }

        H2031_COLUMNS.add(col("reportPeriod", "报表期", 100));
        H2031_COLUMNS.add(col("regionCode", "所属地区", 100));
        H2031_COLUMNS.add(col("enterpriseCode", "企业代码", 130));
        H2031_COLUMNS.add(col("enterpriseName", "企业名称", 220));
        H2031_COLUMNS.add(col("vehicleTotal", "客运车辆合计", 110));
        H2031_COLUMNS.add(col("seatTotal", "核定载客位合计", 130));
        H2031_COLUMNS.add(col("vehicleSchedule", "班线车辆数", 110));
        H2031_COLUMNS.add(col("seatSchedule", "班线载客位", 110));
        H2031_COLUMNS.add(col("vehicleCharter", "包车车辆数", 110));
        H2031_COLUMNS.add(col("seatCharter", "包车载客位", 110));
        H2031_COLUMNS.add(col("passengerTotal", "客运量合计", 110));
        H2031_COLUMNS.add(col("turnoverTotal", "周转量合计", 110));
        H2031_COLUMNS.add(col("passengerClass1", "客运量一类", 110));
        H2031_COLUMNS.add(col("passengerClass2", "客运量二类", 110));
        H2031_COLUMNS.add(col("passengerClass3", "客运量三类", 110));
        H2031_COLUMNS.add(col("passengerClass4", "客运量四类", 110));
        H2031_COLUMNS.add(col("passengerCharter", "客运量包车", 110));
        H2031_COLUMNS.add(col("turnoverClass1", "周转量一类", 110));
        H2031_COLUMNS.add(col("turnoverClass2", "周转量二类", 110));
        H2031_COLUMNS.add(col("turnoverClass3", "周转量三类", 110));
        H2031_COLUMNS.add(col("turnoverClass4", "周转量四类", 110));
        H2031_COLUMNS.add(col("turnoverCharter", "周转量包车", 110));
        H2031_COLUMNS.add(col("avgDistanceTotal", "平均运距合计", 120));
        H2031_COLUMNS.add(col("avgDistanceClass1", "一类平均运距", 120));
        H2031_COLUMNS.add(col("avgDistanceClass2", "二类平均运距", 120));
        H2031_COLUMNS.add(col("avgDistanceClass3", "三类平均运距", 120));
        H2031_COLUMNS.add(col("avgDistanceClass4", "四类平均运距", 120));
        H2031_COLUMNS.add(col("avgDistanceCharter", "包车平均运距", 120));
        BUS_COLUMNS.add(col("reportPeriod", "报表期", 100));
        BUS_COLUMNS.add(col("regionCode", "所属地区", 100));
        BUS_COLUMNS.add(col("city", "市州", 110));
        BUS_COLUMNS.add(col("enterpriseName", "企业名称", 220));
        BUS_COLUMNS.add(col("opVehicles", "运营车数", 100));
        BUS_COLUMNS.add(col("stopTotal", "站点总个数", 110));
        BUS_COLUMNS.add(col("stopCity", "城市内站点", 110));
        BUS_COLUMNS.add(col("passengerVolume", "客运量", 100));
        BUS_COLUMNS.add(col("passengerCity", "城市内客运量", 120));
        BUS_COLUMNS.add(col("turnover", "旅客周转量", 110));
        BUS_COLUMNS.add(col("turnoverCity", "城市内周转量", 120));
        BUS_COLUMNS.add(col("avgDistance", "平均运距", 100));
        BUS_COLUMNS.add(col("avgDistanceCity", "城市内平均运距", 130));
        BUS_COLUMNS.add(col("passengerChengxiang", "城际城乡客运量", 130));
        BUS_COLUMNS.add(col("turnoverChengxiang", "城际城乡周转量", 130));
        BUS_COLUMNS.add(col("avgDistanceChengxiang", "城际城乡平均运距", 140));
        BUS_COLUMNS.add(col("ratePassengerMom", "客运量环比", 100));
        BUS_COLUMNS.add(col("ratePassengerCityMom", "城市内环比", 100));
        BUS_COLUMNS.add(col("rateChengxiangMom", "城际城乡环比", 110));
        BUS_COLUMNS.add(col("ratePassengerYoy", "客运量同比", 100));
        BUS_COLUMNS.add(col("passengerCityRatio", "城市内占比", 100));
        BUS_COLUMNS.add(col("chengxiangRatio", "城际城乡占比", 110));
        BUS_COLUMNS.add(col("contactPerson", "填表人", 100));
        BUS_COLUMNS.add(col("reportDate", "报出日期", 110));
        BUS_COLUMNS.add(col("verifyExplanation", "核实解释", 220));
        TAXI_COLUMNS.add(col("reportPeriod", "报表期", 100));
        TAXI_COLUMNS.add(col("regionCode", "所属地区", 100));
        TAXI_COLUMNS.add(col("city", "市州", 110));
        TAXI_COLUMNS.add(col("tripTotal", "载客车次总数", 120));
        TAXI_COLUMNS.add(col("tripCity", "载客车次_城市内", 130));
        TAXI_COLUMNS.add(col("passengerVolume", "客运量", 100));
        TAXI_COLUMNS.add(col("passengerCity", "城市内客运量", 120));
        TAXI_COLUMNS.add(col("turnover", "旅客周转量", 110));
        TAXI_COLUMNS.add(col("turnoverCity", "城市内周转量", 120));
        TAXI_COLUMNS.add(col("opVehicles", "运营车辆数", 110));
        TAXI_COLUMNS.add(col("avgDistance", "平均运距", 100));
        TAXI_COLUMNS.add(col("avgDistanceCity", "城市内平均运距", 130));
        TAXI_COLUMNS.add(col("passengersPerTrip", "单车次载客人数", 130));
        TAXI_COLUMNS.add(col("rateTripMom", "载客车次环比", 110));
        TAXI_COLUMNS.add(col("rateTripYoy", "载客车次同比", 110));
        TAXI_COLUMNS.add(col("ratePassengerMom", "客运量环比", 100));
        TAXI_COLUMNS.add(col("ratePassengerYoy", "客运量同比", 100));
        TAXI_COLUMNS.add(col("passengerCityRatio", "城市内客运量占比", 140));
        TAXI_COLUMNS.add(col("avgDistanceChengxiang", "城际城乡平均运距", 140));
        TAXI_COLUMNS.add(col("verifyExplanation", "核实解释", 220));
        TAXI_AUTH_COLUMNS.add(col("reportPeriod", "报表期", 100));
        TAXI_AUTH_COLUMNS.add(col("city", "市州", 110));
        TAXI_AUTH_COLUMNS.add(col("plateNo", "车牌号码", 120));
        TAXI_AUTH_COLUMNS.add(col("vehicleType", "车辆类型", 110));
        TAXI_AUTH_COLUMNS.add(col("fuelType", "燃料类型", 100));
        TAXI_AUTH_COLUMNS.add(col("opStatus", "营运状态", 100));
        TAXI_AUTH_COLUMNS.add(col("certStatus", "证件状态", 100));
        TAXI_AUTH_COLUMNS.add(col("licenseNo", "经营权号", 130));
        TAXI_AUTH_COLUMNS.add(col("archiveNo", "档案号", 130));
        TAXI_AUTH_COLUMNS.add(col("roadCertNo", "道路运输证字号", 150));
        TAXI_AUTH_COLUMNS.add(col("operatorName", "业户名称", 240));
        TAXI_AUTH_COLUMNS.add(col("operatorAddr", "业户地址", 280));
        PAUTH_COLUMNS.add(col("reportPeriod", "报表期", 100));
        PAUTH_COLUMNS.add(col("enterpriseCode", "企业代码", 130));
        PAUTH_COLUMNS.add(col("enterpriseName", "企业名称", 240));
        PAUTH_COLUMNS.add(col("vehicleCount", "车辆数", 100));
        PAUTH_COLUMNS.add(col("seatCount", "载客位数", 100));
    }
}

 traffic-audit-server/src/main/java/com/trafficaudit/dataimport/controller/ExplainController.java

@@ -3,10 +3,17 @@
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.trafficaudit.common.Result;
import com.trafficaudit.dataimport.entity.CityBusMonthly;
import com.trafficaudit.dataimport.entity.CityTaxiMonthly;
import com.trafficaudit.dataimport.entity.H2032EnterpriseMonthly;
import com.trafficaudit.dataimport.entity.PassengerEnterpriseMonthly;
import com.trafficaudit.dataimport.mapper.CityBusMonthlyMapper;
import com.trafficaudit.dataimport.mapper.CityTaxiMonthlyMapper;
import com.trafficaudit.dataimport.mapper.H2032EnterpriseMonthlyMapper;
import com.trafficaudit.dataimport.mapper.PassengerEnterpriseMonthlyMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
@@ -18,7 +25,8 @@
import java.util.Map;

/**
 * ä¼ä¸šè§£é‡Šï¼šç‹¬ç«‹äºŽå®¡æ ¸ç»“果的解释列表与 AI åˆ†æžå…¥å£
 * ä¼ä¸šè§£é‡Šï¼šç‹¬ç«‹äºŽå®¡æ ¸ç»“果的解释列表与 AI åˆ†æžå…¥å£ã€‚
 * æ”¯æŒå¤šæŠ¥è¡¨ç±»åž‹ï¼šH2032 è´§è¿ã€H2031 å…¬è·¯æ—…客、CITY_BUS åŸŽå¸‚公交、CITY_TAXI å·¡æ¸¸å‡ºç§Ÿã€‚
 */
@Slf4j
@RestController
@@ -27,47 +35,171 @@

    @Resource
    private H2032EnterpriseMonthlyMapper h2032Mapper;
    @Resource
    private PassengerEnterpriseMonthlyMapper passengerMapper;
    @Resource
    private CityBusMonthlyMapper cityBusMapper;
    @Resource
    private CityTaxiMonthlyMapper cityTaxiMapper;

    @GetMapping("/list")
    public Result<Map<String, Object>> list(@RequestParam(value = "period", required = false) String period,
    public Result<Map<String, Object>> list(@RequestParam(value = "reportType", defaultValue = "H2032") String reportType,
                                            @RequestParam(value = "period", required = false) String period,
                                            @RequestParam(value = "keyword", required = false) String keyword,
                                            @RequestParam(value = "hasExplanation", defaultValue = "false") boolean hasExplanation,
                                            @RequestParam(value = "page", defaultValue = "1") long page,
                                            @RequestParam(value = "size", defaultValue = "20") long size) {
        String kw = keyword == null ? "" : keyword.trim();
        boolean hasPeriod = period != null && !period.trim().isEmpty();

        LambdaQueryWrapper<H2032EnterpriseMonthly> w = new LambdaQueryWrapper<H2032EnterpriseMonthly>()
            .eq(hasPeriod, H2032EnterpriseMonthly::getReportPeriod, period)
            .isNotNull(H2032EnterpriseMonthly::getVerifyExplanation)
            .ne(H2032EnterpriseMonthly::getVerifyExplanation, "")
            .like(!kw.isEmpty(), H2032EnterpriseMonthly::getEnterpriseName, kw)
            .orderByDesc(H2032EnterpriseMonthly::getId);

        Page<H2032EnterpriseMonthly> p = new Page<>(Math.max(page, 1), Math.min(Math.max(size, 1), 200));
        Page<H2032EnterpriseMonthly> r = h2032Mapper.selectPage(p, w);
        long p = Math.max(page, 1);
        long s = Math.min(Math.max(size, 1), 200);

        List<Map<String, Object>> records = new ArrayList<>();
        long total = 0;

        if ("H2031".equals(reportType)) {
            LambdaQueryWrapper<PassengerEnterpriseMonthly> w = new LambdaQueryWrapper<PassengerEnterpriseMonthly>()
                .eq(hasPeriod, PassengerEnterpriseMonthly::getReportPeriod, period)
                .isNotNull(hasExplanation, PassengerEnterpriseMonthly::getVerifyExplanation)
                .ne(hasExplanation, PassengerEnterpriseMonthly::getVerifyExplanation, "")
                .like(!kw.isEmpty(), PassengerEnterpriseMonthly::getEnterpriseName, kw)
                .orderByDesc(PassengerEnterpriseMonthly::getId);
            Page<PassengerEnterpriseMonthly> r = passengerMapper.selectPage(new Page<>(p, s), w);
            for (PassengerEnterpriseMonthly e : r.getRecords()) {
                Map<String, Object> row = baseRow(e.getId(), e.getReportPeriod(), e.getRegionCode(),
                        e.getEnterpriseCode(), e.getEnterpriseName(), e.getVerifyExplanation());
                row.put("vehicleTotal", e.getVehicleTotal());
                row.put("seatTotal", e.getSeatTotal());
                row.put("passengerTotal", e.getPassengerTotal());
                row.put("turnoverTotal", e.getTurnoverTotal());
                row.put("avgDistance", e.getAvgDistanceTotal());
                records.add(row);
            }
            total = r.getTotal();
        } else if ("CITY_BUS".equals(reportType)) {
            LambdaQueryWrapper<CityBusMonthly> w = new LambdaQueryWrapper<CityBusMonthly>()
                .eq(hasPeriod, CityBusMonthly::getReportPeriod, period)
                .isNotNull(hasExplanation, CityBusMonthly::getVerifyExplanation)
                .ne(hasExplanation, CityBusMonthly::getVerifyExplanation, "")
                .like(!kw.isEmpty(), CityBusMonthly::getEnterpriseName, kw)
                .orderByDesc(CityBusMonthly::getId);
            Page<CityBusMonthly> r = cityBusMapper.selectPage(new Page<>(p, s), w);
            for (CityBusMonthly e : r.getRecords()) {
                Map<String, Object> row = baseRow(e.getId(), e.getReportPeriod(), e.getRegionCode(),
                        e.getEnterpriseCode(), e.getEnterpriseName(), e.getVerifyExplanation());
                row.put("city", e.getCity());
                row.put("opVehicles", e.getOpVehicles());
                row.put("passengerVolume", e.getPassengerVolume());
                row.put("turnover", e.getTurnover());
                row.put("avgDistance", e.getAvgDistance());
                records.add(row);
            }
            total = r.getTotal();
        } else if ("CITY_TAXI".equals(reportType)) {
            LambdaQueryWrapper<CityTaxiMonthly> w = new LambdaQueryWrapper<CityTaxiMonthly>()
                .eq(hasPeriod, CityTaxiMonthly::getReportPeriod, period)
                .isNotNull(hasExplanation, CityTaxiMonthly::getVerifyExplanation)
                .ne(hasExplanation, CityTaxiMonthly::getVerifyExplanation, "")
                .like(!kw.isEmpty(), CityTaxiMonthly::getCity, kw)
                .orderByDesc(CityTaxiMonthly::getId);
            Page<CityTaxiMonthly> r = cityTaxiMapper.selectPage(new Page<>(p, s), w);
            for (CityTaxiMonthly e : r.getRecords()) {
                Map<String, Object> row = baseRow(e.getId(), e.getReportPeriod(), e.getRegionCode(),
                        null, e.getCity(), e.getVerifyExplanation());
                row.put("city", e.getCity());
                row.put("opVehicles", e.getOpVehicles());
                row.put("tripTotal", e.getTripTotal());
                row.put("passengerVolume", e.getPassengerVolume());
                row.put("turnover", e.getTurnover());
                row.put("avgDistance", e.getAvgDistance());
                records.add(row);
            }
            total = r.getTotal();
        } else {
            LambdaQueryWrapper<H2032EnterpriseMonthly> w = new LambdaQueryWrapper<H2032EnterpriseMonthly>()
                .eq(hasPeriod, H2032EnterpriseMonthly::getReportPeriod, period)
                .isNotNull(hasExplanation, H2032EnterpriseMonthly::getVerifyExplanation)
                .ne(hasExplanation, H2032EnterpriseMonthly::getVerifyExplanation, "")
                .like(!kw.isEmpty(), H2032EnterpriseMonthly::getEnterpriseName, kw)
                .orderByDesc(H2032EnterpriseMonthly::getId);
            Page<H2032EnterpriseMonthly> r = h2032Mapper.selectPage(new Page<>(p, s), w);
        for (H2032EnterpriseMonthly e : r.getRecords()) {
            Map<String, Object> row = new LinkedHashMap<>();
            row.put("id", e.getId());
            row.put("reportPeriod", e.getReportPeriod());
            row.put("regionCode", e.getRegionCode());
            row.put("enterpriseCode", e.getEnterpriseCode());
            row.put("enterpriseName", e.getEnterpriseName());
                Map<String, Object> row = baseRow(e.getId(), e.getReportPeriod(), e.getRegionCode(),
                        e.getEnterpriseCode(), e.getEnterpriseName(), e.getVerifyExplanation());
            row.put("vehicleTotal", e.getVehicleTotal());
            row.put("tonsTotal", e.getTonsTotal());
            row.put("freightTotal", e.getFreightTotal());
            row.put("turnoverTotal", e.getTurnoverTotal());
            row.put("avgDistance", e.getAvgDistance());
            row.put("verifyExplanation", e.getVerifyExplanation());
            records.add(row);
            }
            total = r.getTotal();
        }

        Map<String, Object> result = new LinkedHashMap<>();
        result.put("reportType", reportType);
        result.put("records", records);
        result.put("total", r.getTotal());
        result.put("current", r.getCurrent());
        result.put("size", r.getSize());
        result.put("total", total);
        result.put("current", p);
        result.put("size", s);
        return Result.ok(result);
    }

    /**
     * ä¿å­˜ä¼ä¸šè§£é‡Šï¼šæ›´æ–°å¯¹åº”来源表（H2032/H2031/CITY_BUS/CITY_TAXI）行的 verifyExplanation。
     * å®¡æ ¸ç»“果页内嵌解释模块与「企业解释」页共用此接口。
     */
    @PostMapping("/save")
    public Result<String> save(@RequestParam("reportType") String reportType,
                               @RequestParam("reportId") Long reportId,
                               @RequestParam(value = "explanation", required = false) String explanation) {
        String exp = explanation == null ? "" : explanation.trim();
        boolean ok = false;
        String t = reportType == null ? "" : reportType;
        try {
            switch (t) {
                case "H2032": {
                    H2032EnterpriseMonthly e = h2032Mapper.selectById(reportId);
                    if (e != null) { e.setVerifyExplanation(exp); h2032Mapper.updateById(e); ok = true; }
                    break;
                }
                case "H2031": {
                    PassengerEnterpriseMonthly e = passengerMapper.selectById(reportId);
                    if (e != null) { e.setVerifyExplanation(exp); passengerMapper.updateById(e); ok = true; }
                    break;
                }
                case "CITY_BUS": {
                    CityBusMonthly e = cityBusMapper.selectById(reportId);
                    if (e != null) { e.setVerifyExplanation(exp); cityBusMapper.updateById(e); ok = true; }
                    break;
                }
                case "CITY_TAXI": {
                    CityTaxiMonthly e = cityTaxiMapper.selectById(reportId);
                    if (e != null) { e.setVerifyExplanation(exp); cityTaxiMapper.updateById(e); ok = true; }
                    break;
                }
                default:
                    throw new RuntimeException("不支持的报表类型：" + reportType);
            }
        } catch (Exception e) {
            log.error("explain save error", e);
            return Result.error("保存失败: " + e.getMessage());
        }
        if (!ok) {
            return Result.error("未找到对应的数据行（reportId=" + reportId + "）");
        }
        return Result.ok(exp);
    }

    private Map<String, Object> baseRow(Long id, String reportPeriod, String regionCode,
                                        String enterpriseCode, String enterpriseName, String verifyExplanation) {
        Map<String, Object> row = new LinkedHashMap<>();
        row.put("id", id);
        row.put("reportPeriod", reportPeriod);
        row.put("regionCode", regionCode);
        row.put("enterpriseCode", enterpriseCode);
        row.put("enterpriseName", enterpriseName);
        row.put("verifyExplanation", verifyExplanation);
        return row;
    }
}

 traffic-audit-server/src/main/java/com/trafficaudit/dataimport/entity/CityBusMonthly.java

New file
@@ -0,0 +1,117 @@
package com.trafficaudit.dataimport.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.time.LocalDateTime;

/**
 * åŸŽå¸‚客运第1步：城市公交企业月度数据
 * æ•°æ®æºï¼šå¯¼å…¥_城市公共交通月度运营情况（YYYYå¹´M月）.xls（企业级明细，仅取公共汽电车字段）
 */
@Data
@TableName("city_bus_monthly")
public class CityBusMonthly {
    @TableId(type = IdType.AUTO)
    private Long id;
    /** æŠ¥è¡¨æœŸ 2026-07 */
    private String reportPeriod;
    /** æ‰€å±žåœ°åŒºï¼ˆè¡Œæ”¿åŒºåˆ’代码） */
    private String regionCode;
    /** å¸‚州（由地区代码映射） */
    private String city;
    /** ä¼ä¸šä»£ç  */
    private String enterpriseCode;
    /** ä¼ä¸šåç§° */
    private String enterpriseName;

    /** å…¬å…±æ±½ç”µè½¦è¿è¥è½¦æ•° */
    private Double opVehicles;
    /** è¿è¥ç«™ç‚¹æ€»ä¸ªæ•° */
    private Double stopTotal;
    /** å…¶ä¸­ï¼šåŸŽå¸‚内运营站点 */
    private Double stopCity;
    /** å…¬å…±æ±½ç”µè½¦å®¢è¿é‡ï¼ˆä¸‡äººæ¬¡ï¼‰ */
    private Double passengerVolume;
    /** å…¶ä¸­ï¼šåŸŽå¸‚内客运量（万人次） */
    private Double passengerCity;
    /** å…¬å…±æ±½ç”µè½¦æ—…客周转量（万人公里） */
    private Double turnover;
    /** å…¶ä¸­ï¼šåŸŽå¸‚内旅客周转量（万人公里） */
    private Double turnoverCity;
    /** å…¬å…±æ±½ç”µè½¦å¹³å‡è¿è·ï¼ˆå…¬é‡Œï¼‰ */
    private Double avgDistance;
    /** åŸŽå¸‚内平均运距（公里） */
    private Double avgDistanceCity;
    /** åŸŽé™…城乡客运量（万人次） */
    private Double passengerChengxiang;
    /** åŸŽé™…城乡旅客周转量（万人公里） */
    private Double turnoverChengxiang;
    /** åŸŽé™…城乡平均运距（公里） */
    private Double avgDistanceChengxiang;

    /** è¿è¥è½¦æ•°çŽ¯æ¯”增速 */
    private Double rateOpVehiclesMom;
    /** å®¢è¿é‡çŽ¯æ¯”增速 */
    private Double ratePassengerMom;
    /** åŸŽå¸‚内客运量环比 */
    private Double ratePassengerCityMom;
    /** åŸŽé™…城乡客运量环比增速 */
    private Double rateChengxiangMom;
    /** åŸŽé™…城乡旅客周转量环比增速 */
    private Double rateChengxiangTurnoverMom;
    /** æ—…客周转量环比增速 */
    private Double rateTurnoverMom;
    /** å¹³å‡è¿è·çŽ¯æ¯”增减（公里） */
    private Double avgDistanceMomChange;
    /** åŸŽå¸‚内平均运距环比增减（公里） */
    private Double avgDistanceCityMomChange;
    /** å•è½¦æ—¥å‡å®¢è¿é‡ */
    private Double dailyPassengerPerVehicle;

    /** è¿è¥è½¦æ•°åŒæ¯”增速 */
    private Double rateOpVehiclesYoy;
    /** å®¢è¿é‡åŒæ¯”增速 */
    private Double ratePassengerYoy;
    /** åŸŽå¸‚内客运量同比增速 */
    private Double ratePassengerCityYoy;
    /** åŸŽé™…城乡客运量同比增速 */
    private Double rateChengxiangYoy;
    /** åŸŽé™…城乡旅客周转量同比增速 */
    private Double rateChengxiangTurnoverYoy;
    /** æ—…客周转量同比增速 */
    private Double rateTurnoverYoy;

    /** åŸŽå¸‚内运营站点占比 */
    private Double stopCityRatio;
    /** åŸŽå¸‚内客运量占比 */
    private Double passengerCityRatio;
    /** åŸŽé™…城乡客运量占比 */
    private Double chengxiangRatio;

    /** å¡«è¡¨äºº */
    private String contactPerson;
    /** è”系电话 */
    private String contactPhone;
    /** æŠ¥å‡ºæ—¥æœŸ */
    private String reportDate;
    /** æ ¸å®žæ€§åŽŸå› è§£é‡Š */
    private String verifyExplanation;
    /** ä¸ŠæŠ¥è¯´æ˜Ž */
    private String reportNote;
    /** ä¿®æ”¹è®°å½• */
    private String modifyRecord;

    /** è½¨é“交通_客运量（万人次） */
    private Double railPassengerVolume;
    /** è½¨é“交通_旅客周转量（万人公里） */
    private Double railTurnover;
    /** åŸŽå¸‚客运轮渡_客运量（万人次） */
    private Double ferryPassengerVolume;
    /** åŸŽå¸‚客运轮渡_旅客周转量（万人公里） */
    private Double ferryTurnover;

    private LocalDateTime createdAt;
}

 traffic-audit-server/src/main/java/com/trafficaudit/dataimport/entity/CityTaxiAuth.java

New file
@@ -0,0 +1,49 @@
package com.trafficaudit.dataimport.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.time.LocalDateTime;

/**
 * åŸŽå¸‚客运第2步：出租车运政车辆信息（车辆级明细）
 * æ•°æ®æºï¼šè¾“å…¥_出租车信息(运政车辆信息).xls
 */
@Data
@TableName("city_taxi_auth")
public class CityTaxiAuth {
    @TableId(type = IdType.AUTO)
    private Long id;
    /** æŠ¥è¡¨æœŸ */
    private String reportPeriod;
    /** å¸‚州（由证号/档案号/地址提取） */
    private String city;
    /** è½¦ç‰Œå·ç  */
    private String plateNo;
    /** è½¦è¾†ç±»åž‹ */
    private String vehicleType;
    /** ç»è¥ç±»åž‹ */
    private String bizType;
    /** è½¦ä¸»åç§° */
    private String ownerName;
    /** ç»è¥æƒå· */
    private String licenseNo;
    /** æ¡£æ¡ˆå· */
    private String archiveNo;
    /** é“路运输证字号 */
    private String roadCertNo;
    /** ç‡ƒæ–™ç±»åž‹ */
    private String fuelType;
    /** ä¸šæˆ·åç§° */
    private String operatorName;
    /** ä¸šæˆ·åœ°å€ */
    private String operatorAddr;
    /** è¥è¿çŠ¶æ€ */
    private String opStatus;
    /** è¯ä»¶çŠ¶æ€ */
    private String certStatus;

    private LocalDateTime createdAt;
}

 traffic-audit-server/src/main/java/com/trafficaudit/dataimport/entity/CityTaxiMonthly.java

New file
@@ -0,0 +1,95 @@
package com.trafficaudit.dataimport.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.time.LocalDateTime;

/**
 * åŸŽå¸‚客运第2步：巡游出租汽车运营服务情况月报（市州级）
 * æ•°æ®æºï¼šå¯¼å…¥_巡游出租汽车运营服务情况月报（YYYYå¹´M月）.xls
 */
@Data
@TableName("city_taxi_monthly")
public class CityTaxiMonthly {
    @TableId(type = IdType.AUTO)
    private Long id;
    /** æŠ¥è¡¨æœŸ 2026-07 */
    private String reportPeriod;
    /** æ‰€å±žåœ°åŒºä»£ç  */
    private String regionCode;
    /** å¸‚å·ž */
    private String city;

    /** è½½å®¢è½¦æ¬¡æ€»æ•° */
    private Double tripTotal;
    /** è½½å®¢è½¦æ¬¡æ€»æ•°_城市内 */
    private Double tripCity;
    /** å®¢è¿é‡ï¼ˆä¸‡äººæ¬¡ï¼‰ */
    private Double passengerVolume;
    /** å®¢è¿é‡_其中城市内 */
    private Double passengerCity;
    /** æ—…客周转量（万人公里） */
    private Double turnover;
    /** æ—…客周转量_城市内 */
    private Double turnoverCity;
    /** è¿è¥è½¦è¾†æ•° */
    private Double opVehicles;
    /** å·¡æ¸¸å‡ºç§Ÿæ±½è½¦å¹³å‡è¿è·ï¼ˆå…¬é‡Œï¼‰ */
    private Double avgDistance;
    /** åŸŽå¸‚内平均运距（公里） */
    private Double avgDistanceCity;
    /** å•è½¦æ—¥å‡è½½å®¢è½¦æ¬¡ */
    private Double dailyTripsPerVehicle;
    /** å•è½¦æ—¥å‡å®¢è¿é‡ */
    private Double dailyPassengerPerVehicle;
    /** å•è½¦æ¬¡è½½å®¢äººæ•° */
    private Double passengersPerTrip;
    /** å•è½¦æ¬¡è½½å®¢äººæ•°_城市内 */
    private Double passengersPerTripCity;
    /** å•è½¦æ¬¡è½½å®¢äººæ•°_城际城乡 */
    private Double passengersPerTripChengxiang;

    /** è¿è¥è½¦æ•°çŽ¯æ¯”增速 */
    private Double rateOpVehiclesMom;
    /** è¿è¥è½¦æ•°åŒæ¯”增速 */
    private Double rateOpVehiclesYoy;
    /** è½½å®¢è½¦æ¬¡æ€»æ•°çŽ¯æ¯”增速 */
    private Double rateTripMom;
    /** è½½å®¢è½¦æ¬¡åŒæ¯”增速 */
    private Double rateTripYoy;
    /** å®¢è¿é‡çŽ¯æ¯”增速 */
    private Double ratePassengerMom;
    /** å®¢è¿é‡åŒæ¯”增速 */
    private Double ratePassengerYoy;
    /** å¹³å‡è¿è·çŽ¯æ¯”增减（公里） */
    private Double avgDistanceMomChange;
    /** å¹³å‡è¿è·_城市内环比增减（公里） */
    private Double avgDistanceCityMomChange;
    /** è½½å®¢è½¦æ¬¡æ€»æ•°çŽ¯æ¯”增速_城市内 */
    private Double rateTripCityMom;
    /** å®¢è¿é‡çŽ¯æ¯”增速_城市内 */
    private Double ratePassengerCityMom;
    /** è½½å®¢è½¦æ¬¡æ€»æ•°_城际城乡环比增速 */
    private Double rateTripChengxiangMom;
    /** å®¢è¿é‡_城际城乡环比增速 */
    private Double ratePassengerChengxiangMom;
    /** å¹³å‡è¿è·_城际城乡（公里） */
    private Double avgDistanceChengxiang;

    /** è½½å®¢è½¦æ¬¡æ€»æ•°_城市内占比 */
    private Double tripCityRatio;
    /** å®¢è¿é‡_城市内占比 */
    private Double passengerCityRatio;

    private String contactPerson;
    private String contactPhone;
    private String reportDate;
    private String verifyExplanation;
    private String reportNote;
    private String modifyRecord;

    private LocalDateTime createdAt;
}

 traffic-audit-server/src/main/java/com/trafficaudit/dataimport/entity/EnergyAuthVehicle.java

New file
@@ -0,0 +1,32 @@
package com.trafficaudit.dataimport.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.time.LocalDateTime;

/**
 * é“路货运能耗_运政车辆信息（车牌粒度）
 */
@Data
@TableName("h204_auth_vehicle")
public class EnergyAuthVehicle {
    @TableId(type = IdType.AUTO)
    private Long id;
    /** æŠ¥è¡¨æœŸ */
    private String reportPeriod;
    /** è½¦ç‰Œå· */
    private String plateNo;
    /** è½¦è¾†ç±»åž‹ */
    private String vehicleType;
    /** ç‡ƒæ–™ç±»åž‹ */
    private String fuelType;
    /** æ ‡è®°å¨ä½ï¼ˆå¨ï¼‰ */
    private Double markedTonnage;
    /** å‡†ç‰µå¼•è´¨é‡ï¼ˆç‰µå¼•è½¦æ ‡è®°å¨ä½ï¼‰ */
    private Double tractionQuality;
    private Long importBatchId;
    private LocalDateTime createdAt;
}

 traffic-audit-server/src/main/java/com/trafficaudit/dataimport/entity/EnergyVehicleQuarterly.java

New file
@@ -0,0 +1,70 @@
package com.trafficaudit.dataimport.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.time.LocalDateTime;

/**
 * äº¤ä¼ç»ŸH204表：道路货运车辆能源消耗情况（车辆粒度季报）
 */
@Data
@TableName("h204_vehicle_quarterly")
public class EnergyVehicleQuarterly {
    @TableId(type = IdType.AUTO)
    private Long id;
    /** æŠ¥è¡¨æœŸ 2026-06（季度末月） */
    private String reportPeriod;
    /** æ‰€å±žåœ°åŒºï¼ˆè¡Œæ”¿åŒºåˆ’代码） */
    private String regionCode;
    /** ä¼ä¸šä»£ç  */
    private String enterpriseCode;
    /** ä¼ä¸šåç§° */
    private String enterpriseName;
    /** è½¦ç‰Œå· */
    private String plateNo;
    /** è½¦è¾†ç±»åž‹ä»£ç  */
    private String vehicleTypeCode;
    /** è½¦è¾†ç±»åž‹ï¼ˆä¸­æ–‡ï¼‰ */
    private String vehicleType;
    /** ç‡ƒæ–™ç±»åž‹ä»£ç  */
    private String fuelTypeCode;
    /** ç‡ƒæ–™ç±»åž‹ï¼ˆä¸­æ–‡ï¼‰ */
    private String fuelType;
    /** å‡ºåŽ‚年份 */
    private Integer manufactureYear;
    /** æ ‡è®°å¨ä½ï¼ˆå¨ï¼‰ */
    private Double markedTonnage;
    /** æ€»è¡Œç¨‹ï¼ˆå…¬é‡Œï¼‰ */
    private Double totalMileage;
    /** è½½è´§é‡Œç¨‹ï¼ˆå…¬é‡Œï¼‰ */
    private Double loadedMileage;
    /** ç©ºé©¶é‡Œç¨‹ï¼ˆå…¬é‡Œï¼‰ */
    private Double emptyMileage;
    /** è´§è¿é‡ï¼ˆå¨ï¼‰ */
    private Double freight;
    /** è´§ç‰©å‘¨è½¬é‡ï¼ˆå¨å…¬é‡Œï¼‰ */
    private Double turnover;
    /** è¶Ÿæ¬¡æ•°ï¼ˆä¸ªï¼‰ */
    private Integer tripCount;
    /** ç‡ƒæ–™1计量单位 */
    private String fuelUnit;
    /** ç‡ƒæ–™1消耗量 */
    private Double fuelConsumption;
    /** å¹³å‡è¿è·ï¼ˆå…¬é‡Œï¼‰ */
    private Double avgDistance;
    /** å¹³å‡è½½è´§å¨ä½ï¼ˆå¨ï¼‰ */
    private Double avgLoadedTonnage;
    /** å•è¶Ÿå¹³å‡é‡Œç¨‹ï¼ˆå…¬é‡Œï¼‰ */
    private Double avgTripMileage;
    /** ç™¾å…¬é‡Œå•è€— */
    @TableField("fuel_per_100km")
    private Double fuelPer100km;
    /** å‘¨è½¬é‡å•è€— */
    private Double turnoverFuel;
    private Long importBatchId;
    private LocalDateTime createdAt;
}

 traffic-audit-server/src/main/java/com/trafficaudit/dataimport/entity/InvestmentMonthly.java

New file
@@ -0,0 +1,37 @@
package com.trafficaudit.dataimport.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.time.LocalDateTime;

/**
 * æŠ•èµ„项目月度完成情况
 */
@Data
@TableName("investment_monthly")
public class InvestmentMonthly {
    @TableId(type = IdType.AUTO)
    private Long id;
    /** æŠ¥è¡¨æœŸ 2026-07 */
    private String reportPeriod;
    /** é¡¹ç›®ä¸»æ¡£ID */
    private Long projectId;
    /** æœ¬å¹´è®¡åˆ’投资（万元） */
    private Double yearPlan;
    /** è‡ªå¹´åˆç´¯è®¡å®ŒæˆæŠ•èµ„（万元） */
    private Double yearCum;
    /** å…¶ä¸­ï¼šæœ¬æœˆå®ŒæˆæŠ•èµ„（万元） */
    private Double monthDone;
    /** è‡ªå¼€å§‹å»ºè®¾ç´¯è®¡å®ŒæˆæŠ•èµ„（万元） */
    private Double startCum;
    /** å»ºè®¾é˜¶æ®µ */
    private String progressStage;
    /** å½¢è±¡è¿›åº¦ */
    private String progressDesc;
    /** å»ºç­‘面积（平方米） */
    private Double buildingArea;
    private LocalDateTime createdAt;
}

 traffic-audit-server/src/main/java/com/trafficaudit/dataimport/entity/InvestmentProject.java

New file
@@ -0,0 +1,53 @@
package com.trafficaudit.dataimport.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.time.LocalDateTime;

/**
 * æŠ•èµ„项目主档（客运站场 / ç‰©æµå›­åŒºï¼‰
 */
@Data
@TableName("investment_project")
public class InvestmentProject {
    @TableId(type = IdType.AUTO)
    private Long id;
    /** é¡¹ç›®åç§° */
    private String projectName;
    /** ç±»åˆ«ï¼šå®¢è¿ç«™åœº / ç‰©æµå›­åŒº */
    private String category;
    /** å¸‚å·ž */
    private String city;
    /** åŽ¿ï¼ˆå¸‚、区） */
    private String county;
    /** æŠ•èµ„建设单位 */
    private String builderName;
    /** å»ºè®¾æ€§è´¨ */
    private String constructNature;
    /** å¼€å·¥æ—¶é—´ */
    private String startTime;
    /** å»ºæˆ/竣工时间 */
    private String endTime;
    /** è®¡åˆ’总投资（万元） */
    private Double totalInvestment;
    /** å·¥å¯æ‰¹å¤ */
    private String approvalGk;
    /** åˆè®¾æ‰¹å¤ */
    private String approvalCs;
    /** å»ºç­‘面积（平方米） */
    private Double buildingArea;
    /** äº¿å…ƒæŠ•èµ„项目标记 */
    private Integer isBillion;
    /** ç»æµŽå¼ºåŽ¿é¡¹ç›®æ ‡è®° */
    private Integer isCounty;
    /** åäº”五重点物流项目标记 */
    private Integer isFiveYear;
    /** æ•°æ®æ¥æº */
    private String source;
    private Long importBatchId;
    private LocalDateTime createdAt;
    private LocalDateTime updatedAt;
}

 traffic-audit-server/src/main/java/com/trafficaudit/dataimport/entity/InvestmentSystem.java

New file
@@ -0,0 +1,34 @@
package com.trafficaudit.dataimport.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.time.LocalDateTime;

/**
 * æŠ•èµ„系统查询导出（审核比对基准）
 */
@Data
@TableName("investment_system")
public class InvestmentSystem {
    @TableId(type = IdType.AUTO)
    private Long id;
    /** æŠ¥è¡¨æœŸ 2026-07 */
    private String reportPeriod;
    /** é¡¹ç›®åç§°ï¼ˆå•ä½ï¼‰ */
    private String projectName;
    /** è®¡åˆ’总投资（万元） */
    private Double totalInvestment;
    /** è‡ªå¼€å§‹å»ºè®¾è‡³æœ¬æœˆç´¯è®¡å®ŒæˆæŠ•èµ„（万元） */
    private Double startCum;
    /** æœ¬å¹´è®¡åˆ’投资（万元） */
    private Double yearPlan;
    /** è‡ªå¹´åˆç´¯è®¡å®ŒæˆæŠ•èµ„（万元） */
    private Double yearCum;
    /** å½“月完成投资（万元） */
    private Double monthDone;
    private Long importBatchId;
    private LocalDateTime createdAt;
}

 traffic-audit-server/src/main/java/com/trafficaudit/dataimport/entity/PassengerAuthVehicle.java

New file
@@ -0,0 +1,29 @@
package com.trafficaudit.dataimport.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.time.LocalDateTime;

/**
 * å…¬è·¯æ—…客运政车辆数据（车辆数/载客位数）
 */
@Data
@TableName("passenger_auth_vehicle")
public class PassengerAuthVehicle {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String reportPeriod;
    /** ä¼ä¸šä»£ç  */
    private String enterpriseCode;
    /** ä¼ä¸šåç§° */
    private String enterpriseName;
    /** è½¦è¾†æ•° */
    private Integer vehicleCount;
    /** è½½å®¢ä½æ•° */
    private Integer seatCount;
    private Long importBatchId;
    private LocalDateTime createdAt;
}

 traffic-audit-server/src/main/java/com/trafficaudit/dataimport/entity/PassengerEnterpriseMonthly.java

New file
@@ -0,0 +1,73 @@
package com.trafficaudit.dataimport.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.time.LocalDateTime;

/**
 * äº¤ä¼ç»ŸH203-1表：公路旅客运输月度生产情况
 */
@Data
@TableName("h2031_enterprise_monthly")
public class PassengerEnterpriseMonthly {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String reportPeriod;
    /** æ‰€å±žåœ°åŒºï¼ˆè¡Œæ”¿åŒºåˆ’代码） */
    private String regionCode;
    /** ä¼ä¸šä»£ç  */
    private String enterpriseCode;
    /** ä¼ä¸šåç§° */
    private String enterpriseName;

    /** å®¢è¿è½¦è¾†_总计 */
    private Integer vehicleTotal;
    /** æ ¸å®šè½½å®¢ä½_总计 */
    private Integer seatTotal;
    /** è½¦è¾†æ•°_客运班车（含定线旅游客运客车） */
    private Integer vehicleSchedule;
    /** æ ¸å®šè½½å®¢ä½_客运班车（含定线旅游客运客车） */
    private Integer seatSchedule;
    /** è½¦è¾†æ•°_客运包车（含非定线旅游客运客车） */
    private Integer vehicleCharter;
    /** æ ¸å®šè½½å®¢ä½_客运包车（含非定线旅游客运客车） */
    private Integer seatCharter;

    /** å®¢è¿é‡_总计 */
    private Double passengerTotal;
    /** æ—…客周转量_总计 */
    private Double turnoverTotal;

    /** å®¢è¿é‡_一类客运班线（含定线旅游） */
    private Double passengerClass1;
    private Double turnoverClass1;
    /** å®¢è¿é‡_二类客运班线（含定线旅游） */
    private Double passengerClass2;
    private Double turnoverClass2;
    /** å®¢è¿é‡_三类客运班线（含定线旅游） */
    private Double passengerClass3;
    private Double turnoverClass3;
    /** å®¢è¿é‡_四类客运班线（含定线旅游） */
    private Double passengerClass4;
    private Double turnoverClass4;
    /** å®¢è¿é‡_客运包车（含非定线旅游） */
    private Double passengerCharter;
    private Double turnoverCharter;

    /** å®¢è¿å¹³å‡è¿è· */
    private Double avgDistanceTotal;
    /** ä¸€ç±»å®¢è¿ç­çº¿å¹³å‡è¿è· */
    private Double avgDistanceClass1;
    private Double avgDistanceClass2;
    private Double avgDistanceClass3;
    private Double avgDistanceClass4;
    /** æ—…游、包车平均运距 */
    private Double avgDistanceCharter;

    private String verifyExplanation;
    private Long importBatchId;
    private LocalDateTime createdAt;
}

 traffic-audit-server/src/main/java/com/trafficaudit/dataimport/entity/PassengerIndividualMonthly.java

New file
@@ -0,0 +1,31 @@
package com.trafficaudit.dataimport.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.time.LocalDateTime;

/**
 * å…¬è·¯æ—…客个体客运量/周转量（企业线下汇报，用户导入后按市州汇总填充分市州表个体行）
 */
@Data
@TableName("passenger_individual_monthly")
public class PassengerIndividualMonthly {
    @TableId(type = IdType.AUTO)
    private Long id;
    /** æŠ¥è¡¨æœŸ 2026-07 */
    private String reportPeriod;
    /** æ‰€å±žåœ°åŒºï¼ˆè¡Œæ”¿åŒºåˆ’代码） */
    private String regionCode;
    /** ä¼ä¸šä»£ç  */
    private String enterpriseCode;
    /** ä¼ä¸šåç§° */
    private String enterpriseName;
    /** å…¶ä¸­ä¸ªä½“客运量（人） */
    private Double passengerCount;
    /** å…¶ä¸­ä¸ªä½“旅客周转量（人公里） */
    private Double turnover;
    private LocalDateTime createdAt;
}

 traffic-audit-server/src/main/java/com/trafficaudit/dataimport/mapper/CityBusMonthlyMapper.java

New file
@@ -0,0 +1,6 @@
package com.trafficaudit.dataimport.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.trafficaudit.dataimport.entity.CityBusMonthly;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface CityBusMonthlyMapper extends BaseMapper<CityBusMonthly> {}

 traffic-audit-server/src/main/java/com/trafficaudit/dataimport/mapper/CityTaxiAuthMapper.java

New file
@@ -0,0 +1,6 @@
package com.trafficaudit.dataimport.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.trafficaudit.dataimport.entity.CityTaxiAuth;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface CityTaxiAuthMapper extends BaseMapper<CityTaxiAuth> {}

 traffic-audit-server/src/main/java/com/trafficaudit/dataimport/mapper/CityTaxiMonthlyMapper.java

New file
@@ -0,0 +1,6 @@
package com.trafficaudit.dataimport.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.trafficaudit.dataimport.entity.CityTaxiMonthly;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface CityTaxiMonthlyMapper extends BaseMapper<CityTaxiMonthly> {}

 traffic-audit-server/src/main/java/com/trafficaudit/dataimport/mapper/EnergyAuthVehicleMapper.java

New file
@@ -0,0 +1,9 @@
package com.trafficaudit.dataimport.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.trafficaudit.dataimport.entity.EnergyAuthVehicle;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface EnergyAuthVehicleMapper extends BaseMapper<EnergyAuthVehicle> {
}

 traffic-audit-server/src/main/java/com/trafficaudit/dataimport/mapper/EnergyVehicleQuarterlyMapper.java

New file
@@ -0,0 +1,9 @@
package com.trafficaudit.dataimport.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.trafficaudit.dataimport.entity.EnergyVehicleQuarterly;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface EnergyVehicleQuarterlyMapper extends BaseMapper<EnergyVehicleQuarterly> {
}

 traffic-audit-server/src/main/java/com/trafficaudit/dataimport/mapper/InvestmentMonthlyMapper.java

New file
@@ -0,0 +1,9 @@
package com.trafficaudit.dataimport.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.trafficaudit.dataimport.entity.InvestmentMonthly;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface InvestmentMonthlyMapper extends BaseMapper<InvestmentMonthly> {
}

 traffic-audit-server/src/main/java/com/trafficaudit/dataimport/mapper/InvestmentProjectMapper.java

New file
@@ -0,0 +1,9 @@
package com.trafficaudit.dataimport.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.trafficaudit.dataimport.entity.InvestmentProject;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface InvestmentProjectMapper extends BaseMapper<InvestmentProject> {
}

 traffic-audit-server/src/main/java/com/trafficaudit/dataimport/mapper/InvestmentSystemMapper.java

New file
@@ -0,0 +1,9 @@
package com.trafficaudit.dataimport.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.trafficaudit.dataimport.entity.InvestmentSystem;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface InvestmentSystemMapper extends BaseMapper<InvestmentSystem> {
}

 traffic-audit-server/src/main/java/com/trafficaudit/dataimport/mapper/PassengerAuthVehicleMapper.java

New file
@@ -0,0 +1,6 @@
package com.trafficaudit.dataimport.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.trafficaudit.dataimport.entity.PassengerAuthVehicle;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface PassengerAuthVehicleMapper extends BaseMapper<PassengerAuthVehicle> {}

 traffic-audit-server/src/main/java/com/trafficaudit/dataimport/mapper/PassengerEnterpriseMonthlyMapper.java

New file
@@ -0,0 +1,6 @@
package com.trafficaudit.dataimport.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.trafficaudit.dataimport.entity.PassengerEnterpriseMonthly;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface PassengerEnterpriseMonthlyMapper extends BaseMapper<PassengerEnterpriseMonthly> {}

 traffic-audit-server/src/main/java/com/trafficaudit/dataimport/mapper/PassengerIndividualMonthlyMapper.java

New file
@@ -0,0 +1,6 @@
package com.trafficaudit.dataimport.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.trafficaudit.dataimport.entity.PassengerIndividualMonthly;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface PassengerIndividualMonthlyMapper extends BaseMapper<PassengerIndividualMonthly> {}

 traffic-audit-server/src/main/java/com/trafficaudit/dataimport/service/DataImportService.java

@@ -4,19 +4,45 @@
import com.trafficaudit.auditengine.entity.AuditResult;
import com.trafficaudit.auditengine.mapper.AuditResultMapper;
import com.trafficaudit.common.util.RegionUtil;
import com.trafficaudit.dataimport.entity.EnergyAuthVehicle;
import com.trafficaudit.dataimport.entity.EnergyVehicleQuarterly;
import com.trafficaudit.dataimport.entity.FreightTurnoverImport;
import com.trafficaudit.dataimport.entity.H2032EnterpriseMonthly;
import com.trafficaudit.dataimport.entity.PassengerAuthVehicle;
import com.trafficaudit.dataimport.entity.PassengerEnterpriseMonthly;
import com.trafficaudit.dataimport.entity.PassengerIndividualMonthly;
import com.trafficaudit.dataimport.entity.ImportBatch;
import com.trafficaudit.dataimport.entity.InvestmentMonthly;
import com.trafficaudit.dataimport.entity.InvestmentProject;
import com.trafficaudit.dataimport.entity.InvestmentSystem;
import com.trafficaudit.dataimport.entity.CityBusMonthly;
import com.trafficaudit.dataimport.entity.CityTaxiMonthly;
import com.trafficaudit.dataimport.entity.CityTaxiAuth;
import com.trafficaudit.dataimport.entity.ScaleSplitTransport;
import com.trafficaudit.dataimport.entity.TransportAuthVehicle;
import com.trafficaudit.dataimport.entity.VehicleTrackMileage;
import com.trafficaudit.dataimport.mapper.EnergyAuthVehicleMapper;
import com.trafficaudit.dataimport.mapper.EnergyVehicleQuarterlyMapper;
import com.trafficaudit.dataimport.mapper.FreightTurnoverImportMapper;
import com.trafficaudit.dataimport.mapper.H2032EnterpriseMonthlyMapper;
import com.trafficaudit.dataimport.mapper.PassengerAuthVehicleMapper;
import com.trafficaudit.dataimport.mapper.PassengerEnterpriseMonthlyMapper;
import com.trafficaudit.dataimport.mapper.PassengerIndividualMonthlyMapper;
import com.trafficaudit.rulemanage.mapper.AuditRuleMapper;
import com.trafficaudit.dataimport.mapper.ImportBatchMapper;
import com.trafficaudit.dataimport.mapper.InvestmentMonthlyMapper;
import com.trafficaudit.dataimport.mapper.InvestmentProjectMapper;
import com.trafficaudit.dataimport.mapper.InvestmentSystemMapper;
import com.trafficaudit.dataimport.mapper.CityBusMonthlyMapper;
import com.trafficaudit.dataimport.mapper.CityTaxiMonthlyMapper;
import com.trafficaudit.dataimport.mapper.CityTaxiAuthMapper;
import com.trafficaudit.dataimport.mapper.ScaleSplitTransportMapper;
import com.trafficaudit.dataimport.mapper.TransportAuthVehicleMapper;
import com.trafficaudit.dataimport.mapper.VehicleTrackMileageMapper;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.session.ExecutorType;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.DataFormatter;
@@ -24,10 +50,17 @@
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.usermodel.WorkbookFactory;
import cn.hutool.core.io.IoUtil;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
@@ -36,6 +69,11 @@
import java.util.Set;
import com.trafficaudit.dataimport.dto.ImportResult;
import org.apache.poi.ss.usermodel.DateUtil;
import java.util.Comparator;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.stream.Collectors;

import java.text.SimpleDateFormat;

@@ -47,6 +85,40 @@
public class DataImportService {

    private static final DataFormatter FORMATTER = new DataFormatter();

    /** H204 èƒ½è€—明细车辆类型码 -> ä¸­æ–‡ */
    private static final Map<String, String> ENERGY_VEHICLE_TYPE_NAMES = new HashMap<>();

    /** H204 èƒ½è€—明细燃料类型码 -> ä¸­æ–‡ */
    private static final Map<String, String> ENERGY_FUEL_TYPE_NAMES = new HashMap<>();

    /** H204 ç‡ƒæ–™1计量单位码 -> ä¸­æ–‡å•ä½ */
    private static final Map<String, String> ENERGY_FUEL_UNIT_NAMES = new HashMap<>();

    static {
        ENERGY_VEHICLE_TYPE_NAMES.put("01", "普通货车");
        ENERGY_VEHICLE_TYPE_NAMES.put("02", "平板货车");
        ENERGY_VEHICLE_TYPE_NAMES.put("03", "仓栅式货车");
        ENERGY_VEHICLE_TYPE_NAMES.put("04", "厢式货车");
        ENERGY_VEHICLE_TYPE_NAMES.put("06", "罐式货车");
        ENERGY_VEHICLE_TYPE_NAMES.put("07", "特殊结构货车");
        ENERGY_VEHICLE_TYPE_NAMES.put("08", "自卸货车");
        ENERGY_VEHICLE_TYPE_NAMES.put("09", "车辆运输车");
        ENERGY_VEHICLE_TYPE_NAMES.put("11", "重型半挂牵引车");

        ENERGY_FUEL_TYPE_NAMES.put("01", "汽油");
        ENERGY_FUEL_TYPE_NAMES.put("02", "柴油");
        ENERGY_FUEL_TYPE_NAMES.put("03", "压缩天然气");
        ENERGY_FUEL_TYPE_NAMES.put("04", "液化天然气");
        ENERGY_FUEL_TYPE_NAMES.put("07", "电动");
        ENERGY_FUEL_TYPE_NAMES.put("08", "氢气");

        ENERGY_FUEL_UNIT_NAMES.put("1", "升");
        ENERGY_FUEL_UNIT_NAMES.put("2", "升");
        ENERGY_FUEL_UNIT_NAMES.put("4", "千克");
        ENERGY_FUEL_UNIT_NAMES.put("5", "千克");
        ENERGY_FUEL_UNIT_NAMES.put("7", "千瓦时");
    }

    @Resource
    private H2032EnterpriseMonthlyMapper h2032Mapper;
@@ -62,6 +134,32 @@
    private FreightTurnoverImportMapper freightTurnoverMapper;
    @Resource
    private AuditResultMapper auditResultMapper;
    @Resource
    private PassengerEnterpriseMonthlyMapper passengerMapper;
    @Resource
    private PassengerIndividualMonthlyMapper passengerIndividualMapper;
    @Resource
    private PassengerAuthVehicleMapper passengerAuthMapper;
    @Resource
    private AuditRuleMapper ruleMapper;
    @Resource
    private EnergyVehicleQuarterlyMapper energyMapper;
    @Resource
    private EnergyAuthVehicleMapper energyAuthMapper;
    @Resource
    private InvestmentProjectMapper investProjectMapper;
    @Resource
    private InvestmentMonthlyMapper investMonthlyMapper;
    @Resource
    private InvestmentSystemMapper investSystemMapper;
    @Resource
    private CityBusMonthlyMapper cityBusMapper;
    @Resource
    private CityTaxiMonthlyMapper cityTaxiMapper;
    @Resource
    private CityTaxiAuthMapper cityTaxiAuthMapper;
    @Resource
    private SqlSessionFactory sqlSessionFactory;

    // ========== H2032 æœˆæŠ¥ ==========

@@ -136,11 +234,18 @@
            throw e;
        }

        // å¹‚等：同报表期重新导入，先删除旧数据
        // å¹‚等：同报表期重新导入，先删除旧数据（只清 H2032 è§„则的审核结果）
        h2032Mapper.delete(new LambdaQueryWrapper<H2032EnterpriseMonthly>()
            .eq(H2032EnterpriseMonthly::getReportPeriod, period));
        List<Long> h2032RuleIds = new ArrayList<>();
        for (com.trafficaudit.rulemanage.entity.AuditRule rule : ruleMapper.selectList(null)) {
            if ("H2032".equals(rule.getReportType())) h2032RuleIds.add(rule.getId());
        }
        if (!h2032RuleIds.isEmpty()) {
        auditResultMapper.delete(new LambdaQueryWrapper<AuditResult>()
            .eq(AuditResult::getReportPeriod, period));
                .eq(AuditResult::getReportPeriod, period)
                .in(AuditResult::getRuleId, h2032RuleIds));
        }

        int success = 0;
        List<String> failDetails = new ArrayList<>();
@@ -170,6 +275,439 @@
        return new ImportResult(success, failDetails.size(), failDetails);
    }


    // ========== H203-1 å…¬è·¯æ—…客月报（含运政车辆数sheet） ==========

    public ImportResult importPassengerMonthly(MultipartFile file, String period) throws Exception {
        List<PassengerRow> rows = new ArrayList<>();
        List<PassengerAuthVehicle> authList = new ArrayList<>();
        try (Workbook wb = WorkbookFactory.create(file.getInputStream())) {
            // sheet0: å…¬è·¯æ—…客6月报
            Sheet sheet = wb.getSheetAt(0);
            Map<String, Integer> colMap = buildHeaderMap(sheet.getRow(0));
            for (int r = 1; r <= sheet.getLastRowNum(); r++) {
                Row row = sheet.getRow(r);
                if (row == null) continue;
                String name = gs(row, colMap, "企业名称");
                if (name == null || name.trim().isEmpty()) continue;
                PassengerEnterpriseMonthly entity = new PassengerEnterpriseMonthly();
                entity.setReportPeriod(period);
                entity.setRegionCode(gs(row, colMap, "所属地区"));
                entity.setEnterpriseCode(gs(row, colMap, "企业代码"));
                entity.setEnterpriseName(name.trim());
                entity.setVehicleTotal(gi(row, colMap, "客运车辆_总计"));
                entity.setSeatTotal(gi(row, colMap, "核定载客位_总计"));
                entity.setVehicleSchedule(gi(row, colMap, "车辆数_客运班车（含定线旅游客运客车）"));
                entity.setSeatSchedule(gi(row, colMap, "核定载客位_客运班车（含定线旅游客运客车）"));
                entity.setVehicleCharter(gi(row, colMap, "车辆数_客运包车（含非定线旅游客运客车）"));
                entity.setSeatCharter(gi(row, colMap, "核定载客位_客运包车（含非定线旅游客运客车）"));
                entity.setPassengerTotal(gd(row, colMap, "客运量_总计"));
                entity.setTurnoverTotal(gd(row, colMap, "旅客周转量_总计"));
                entity.setPassengerClass1(gd(row, colMap, "客运量_一类客运班线（含定线旅游）"));
                entity.setTurnoverClass1(gd(row, colMap, "旅客周转量_一类客运班线（含定线旅游）"));
                entity.setPassengerClass2(gd(row, colMap, "客运量_二类客运班线（含定线旅游）"));
                entity.setTurnoverClass2(gd(row, colMap, "旅客周转量_二类客运班线（含定线旅游）"));
                entity.setPassengerClass3(gd(row, colMap, "客运量_三类客运班线（含定线旅游）"));
                entity.setTurnoverClass3(gd(row, colMap, "旅客周转量_三类客运班线（含定线旅游）"));
                entity.setPassengerClass4(gd(row, colMap, "客运量_四类客运班线（含定线旅游）"));
                entity.setTurnoverClass4(gd(row, colMap, "旅客周转量_四类客运班线（含定线旅游）"));
                entity.setPassengerCharter(gd(row, colMap, "客运量_客运包车（含非定线旅游）"));
                entity.setTurnoverCharter(gd(row, colMap, "旅客周转量_客运包车（含非定线旅游）"));
                entity.setAvgDistanceTotal(gd(row, colMap, "客运平均运距"));
                entity.setAvgDistanceClass1(gd(row, colMap, "一类客运班线平均运距"));
                entity.setAvgDistanceClass2(gd(row, colMap, "二类客运班线平均运距"));
                entity.setAvgDistanceClass3(gd(row, colMap, "三类客运班线平均运距"));
                entity.setAvgDistanceClass4(gd(row, colMap, "四类客运班线平均运距"));
                entity.setAvgDistanceCharter(gd(row, colMap, "旅游、包车平均运距"));
                entity.setVerifyExplanation(gs(row, colMap, "核实性原因解释"));
                rows.add(new PassengerRow(r + 1, entity));
            }
            // sheet1: è¿æ”¿è½¦è¾†æ•°ï¼ˆå›ºå®š4列：企业代码/企业名称/车辆数/载客位数）
            if (wb.getNumberOfSheets() > 1) {
                Sheet authSheet = wb.getSheetAt(1);
                for (int r = 1; r <= authSheet.getLastRowNum(); r++) {
                    Row row = authSheet.getRow(r);
                    if (row == null) continue;
                    String name = getString(row, 1);
                    if (name == null || name.trim().isEmpty()) continue;
                    PassengerAuthVehicle auth = new PassengerAuthVehicle();
                    auth.setReportPeriod(period);
                    auth.setEnterpriseCode(getString(row, 0));
                    auth.setEnterpriseName(name.trim());
                    auth.setVehicleCount(getInt(row, 2));
                    auth.setSeatCount(getInt(row, 3));
                    authList.add(auth);
                }
            }
        } catch (Exception e) {
            log.error("Passenger monthly parse error", e);
            throw e;
        }

        // å¹‚等：同报表期重新导入，先删除旧数据
        passengerMapper.delete(new LambdaQueryWrapper<PassengerEnterpriseMonthly>()
            .eq(PassengerEnterpriseMonthly::getReportPeriod, period));
        passengerAuthMapper.delete(new LambdaQueryWrapper<PassengerAuthVehicle>()
            .eq(PassengerAuthVehicle::getReportPeriod, period));
        // åªæ¸… H2031 è§„则产生的审核结果，避免误删同期的货运审核结果
        List<Long> h2031RuleIds = new ArrayList<>();
        for (com.trafficaudit.rulemanage.entity.AuditRule rule : ruleMapper.selectList(null)) {
            if ("H2031".equals(rule.getReportType())) h2031RuleIds.add(rule.getId());
        }
        if (!h2031RuleIds.isEmpty()) {
            auditResultMapper.delete(new LambdaQueryWrapper<AuditResult>()
                .eq(AuditResult::getReportPeriod, period)
                .in(AuditResult::getRuleId, h2031RuleIds));
        }

        int success = 0;
        List<String> failDetails = new ArrayList<>();
        for (PassengerRow item : rows) {
            try {
                passengerMapper.insert(item.entity);
                success++;
            } catch (Exception e) {
                Throwable cause = e;
                while (cause.getCause() != null) {
                    cause = cause.getCause();
                }
                String reason = cause.getMessage();
                if (reason == null || reason.trim().isEmpty()) {
                    reason = e.getMessage();
                }
                failDetails.add("第 " + item.excelRow + " è¡Œï¼ˆ" + item.entity.getEnterpriseName() + "）：" + reason);
                log.error("Passenger insert error: row {}, {}", item.excelRow, item.entity.getEnterpriseName(), e);
            }
        }
        String errorDetail = String.join("\n", failDetails);
        if (errorDetail.length() > 4000) {
            errorDetail = errorDetail.substring(0, 4000) + "\n……";
        }
        recordBatch(file.getOriginalFilename(), "H2031", period, rows.size(), success, failDetails.size(), errorDetail);

        int authSuccess = 0;
        for (PassengerAuthVehicle auth : authList) {
            try {
                passengerAuthMapper.insert(auth);
                authSuccess++;
            } catch (Exception e) {
                log.error("passenger auth insert error: {}", auth.getEnterpriseName(), e);
            }
        }
        recordBatch(file.getOriginalFilename(), "PASSENGER_AUTH", period, authList.size(), authSuccess, 0, null);
        log.info("Passenger monthly imported: {} rows, auth {} rows for {}", success, authSuccess, period);
        return new ImportResult(success, failDetails.size(), failDetails);
    }



    /** å…¬è·¯æ—…客个体客运量/周转量（企业线下汇报数据，按所属地区导入，供分市州表个体行填充） */
    public ImportResult importPassengerIndividual(MultipartFile file, String period) throws Exception {
        List<PassengerIndividualMonthly> rows = new ArrayList<>();
        try (Workbook wb = WorkbookFactory.create(file.getInputStream())) {
            Sheet sheet = wb.getSheetAt(0);
            Map<String, Integer> colMap = buildHeaderMap(sheet.getRow(0));
            Integer codeCol = colMap.get("所属地区");
            Integer entCol = colMap.get("企业代码");
            Integer nameCol = colMap.get("企业名称");
            Integer passCol = null;
            Integer turnCol = null;
            for (Map.Entry<String, Integer> e : colMap.entrySet()) {
                String k = e.getKey();
                if (k != null && k.contains("个体") && k.contains("客运量")) passCol = e.getValue();
                if (k != null && k.contains("个体") && (k.contains("周转量") || k.contains("周转"))) turnCol = e.getValue();
            }
            if (passCol == null && turnCol == null) {
                throw new RuntimeException("未找到「个体客运量/个体旅客周转量」列，请检查模板（列名需包含“个体客运量”“个体周转量”）");
            }
            for (int r = 1; r <= sheet.getLastRowNum(); r++) {
                Row row = sheet.getRow(r);
                if (row == null) continue;
                String name = nameCol != null ? getString(row, nameCol) : null;
                if (name == null || name.trim().isEmpty()) continue;
                Double pass = passCol != null ? getDecimalOrNull(row, passCol) : null;
                Double turn = turnCol != null ? getDecimalOrNull(row, turnCol) : null;
                if ((pass == null || pass == 0.0) && (turn == null || turn == 0.0)) continue;
                PassengerIndividualMonthly entity = new PassengerIndividualMonthly();
                entity.setReportPeriod(period);
                entity.setRegionCode(codeCol != null ? getString(row, codeCol) : null);
                entity.setEnterpriseCode(entCol != null ? getString(row, entCol) : null);
                entity.setEnterpriseName(name.trim());
                entity.setPassengerCount(pass);
                entity.setTurnover(turn);
                rows.add(entity);
            }
        } catch (Exception e) {
            log.error("Passenger individual parse error", e);
            throw e;
        }
        passengerIndividualMapper.delete(new LambdaQueryWrapper<PassengerIndividualMonthly>()
            .eq(PassengerIndividualMonthly::getReportPeriod, period));
        int success = 0;
        List<String> failDetails = new ArrayList<>();
        for (PassengerIndividualMonthly item : rows) {
            try {
                passengerIndividualMapper.insert(item);
                success++;
            } catch (Exception e) {
                Throwable cause = e;
                while (cause.getCause() != null) {
                    cause = cause.getCause();
                }
                String reason = cause.getMessage();
                if (reason == null || reason.trim().isEmpty()) {
                    reason = e.getMessage();
                }
                failDetails.add("第 " + (rows.indexOf(item) + 2) + " è¡Œï¼ˆ" + item.getEnterpriseName() + "）：" + reason);
            }
        }
        String errorDetail = String.join("\n", failDetails);
        if (errorDetail.length() > 4000) {
            errorDetail = errorDetail.substring(0, 4000) + "\n……";
        }
        recordBatch(file.getOriginalFilename(), "PASSENGER_INDIVIDUAL", period, rows.size(), success, failDetails.size(), errorDetail);
        log.info("Passenger individual imported: {} rows for {}", success, period);
        return new ImportResult(success, failDetails.size(), failDetails);
    }

    /** å…¬è·¯æ—…客运政车辆数（独立模板：企业代码/企业名称/车辆数/载客位数） */
    public ImportResult importPassengerAuth(MultipartFile file, String period) throws Exception {
        List<PassengerAuthVehicle> authList = new ArrayList<>();
        try (Workbook wb = WorkbookFactory.create(file.getInputStream())) {
            Sheet sheet = wb.getSheetAt(0);
            Map<String, Integer> colMap = buildHeaderMap(sheet.getRow(0));
            for (int r = 1; r <= sheet.getLastRowNum(); r++) {
                Row row = sheet.getRow(r);
                if (row == null) continue;
                String name = gs(row, colMap, "企业名称");
                if (name == null || name.trim().isEmpty()) continue;
                PassengerAuthVehicle auth = new PassengerAuthVehicle();
                auth.setReportPeriod(period);
                auth.setEnterpriseCode(gs(row, colMap, "企业代码"));
                auth.setEnterpriseName(name.trim());
                auth.setVehicleCount(gi(row, colMap, "车辆数"));
                auth.setSeatCount(gi(row, colMap, "载客位数"));
                authList.add(auth);
            }
        } catch (Exception e) {
            log.error("Passenger auth parse error", e);
            throw e;
        }
        // å¹‚等：同报表期重新导入，先删除旧数据
        passengerAuthMapper.delete(new LambdaQueryWrapper<PassengerAuthVehicle>()
            .eq(PassengerAuthVehicle::getReportPeriod, period));
        deleteRuleResults("H2031", period);
        int success = 0;
        List<String> failDetails = new ArrayList<>();
        for (PassengerAuthVehicle auth : authList) {
            try {
                passengerAuthMapper.insert(auth);
                success++;
            } catch (Exception e) {
                Throwable cause = e;
                while (cause.getCause() != null) cause = cause.getCause();
                String reason = cause.getMessage();
                if (reason == null || reason.trim().isEmpty()) reason = e.getMessage();
                failDetails.add("第 " + (authList.indexOf(auth) + 2) + " è¡Œï¼ˆ" + auth.getEnterpriseName() + "）：" + reason);
                log.error("Passenger auth insert error: {}", auth.getEnterpriseName(), e);
            }
        }
        String errorDetail = String.join("\n", failDetails);
        if (errorDetail.length() > 4000) errorDetail = errorDetail.substring(0, 4000) + "\n……";
        recordBatch(file.getOriginalFilename(), "PASSENGER_AUTH", period, authList.size(), success, failDetails.size(), errorDetail);
        log.info("Passenger auth imported: {} rows for {}", success, period);
        return new ImportResult(success, failDetails.size(), failDetails);
    }

    // ========== H204 é“路货运车辆能源消耗情况（季报，含运政车辆信息sheet） ==========

    /** èƒ½è€—明细每组固定18列，车牌号起始列（0-based）：3,21,39,57,75 */
    private static final int[] ENERGY_GROUP_COLS = {3, 21, 39, 57, 75};

    public ImportResult importEnergyMonthly(MultipartFile file, String period) throws Exception {
        List<EnergyRow> rows = new ArrayList<>();
        List<EnergyAuthVehicle> authList = new ArrayList<>();
        try (Workbook wb = WorkbookFactory.create(file.getInputStream())) {
            // sheet0: ç¬¬äºŒå­£åº¦è´§è½¦èƒ½è€—明细（每行左右各5组车辆，每组固定18列）
            Sheet sheet = wb.getSheetAt(0);
            for (int r = 1; r <= sheet.getLastRowNum(); r++) {
                Row row = sheet.getRow(r);
                if (row == null) continue;
                String enterpriseName = getString(row, 2);
                if (enterpriseName == null || enterpriseName.trim().isEmpty()) continue;
                for (int group : ENERGY_GROUP_COLS) {
                    String plate = getString(row, group);
                    if (plate == null || plate.trim().isEmpty()) continue;
                    EnergyVehicleQuarterly e = new EnergyVehicleQuarterly();
                    e.setReportPeriod(period);
                    e.setRegionCode(getString(row, 0));
                    e.setEnterpriseCode(getString(row, 1));
                    e.setEnterpriseName(enterpriseName.trim());
                    e.setPlateNo(plate.trim());
                    String vtc = getString(row, group + 1);
                    e.setVehicleTypeCode(vtc);
                    e.setVehicleType(vtc == null ? null : ENERGY_VEHICLE_TYPE_NAMES.getOrDefault(vtc, vtc));
                    String ftc = getString(row, group + 2);
                    e.setFuelTypeCode(ftc);
                    e.setFuelType(ftc == null ? null : ENERGY_FUEL_TYPE_NAMES.getOrDefault(ftc, ftc));
                    e.setManufactureYear(getIntOrNull(row, group + 3));
                    e.setMarkedTonnage(getDecimalOrNull(row, group + 4));
                    e.setTotalMileage(getDecimalOrNull(row, group + 5));
                    e.setLoadedMileage(getDecimalOrNull(row, group + 6));
                    e.setEmptyMileage(getDecimalOrNull(row, group + 7));
                    e.setFreight(getDecimalOrNull(row, group + 8));
                    e.setTurnover(getDecimalOrNull(row, group + 9));
                    e.setTripCount(getIntOrNull(row, group + 10));
                    String unit = getString(row, group + 11);
                    e.setFuelUnit(unit == null ? null : ENERGY_FUEL_UNIT_NAMES.getOrDefault(unit, unit));
                    e.setFuelConsumption(getDecimalOrNull(row, group + 12));
                    e.setAvgDistance(getDecimalOrNull(row, group + 13));
                    e.setAvgLoadedTonnage(getDecimalOrNull(row, group + 14));
                    e.setAvgTripMileage(getDecimalOrNull(row, group + 15));
                    e.setFuelPer100km(getDecimalOrNull(row, group + 16));
                    e.setTurnoverFuel(getDecimalOrNull(row, group + 17));
                    rows.add(new EnergyRow(r + 1, e));
                }
            }
            // sheet1: è¿æ”¿è½¦è¾†ä¿¡æ¯ï¼ˆå›ºå®š5列：车牌号/车辆类型/燃料类型/标记吨位/准牵引质量）
            if (wb.getNumberOfSheets() > 1) {
                Sheet authSheet = wb.getSheetAt(1);
                for (int r = 1; r <= authSheet.getLastRowNum(); r++) {
                    Row row = authSheet.getRow(r);
                    if (row == null) continue;
                    String plate = getString(row, 0);
                    if (plate == null || plate.trim().isEmpty()) continue;
                    EnergyAuthVehicle auth = new EnergyAuthVehicle();
                    auth.setReportPeriod(period);
                    auth.setPlateNo(plate.trim());
                    auth.setVehicleType(getString(row, 1));
                    auth.setFuelType(getString(row, 2));
                    auth.setMarkedTonnage(getDecimal(row, 3));
                    auth.setTractionQuality(getDecimal(row, 4));
                    authList.add(auth);
                }
            }
        } catch (Exception e) {
            log.error("Energy monthly parse error", e);
            throw e;
        }

        // å¹‚等：同报表期重新导入，先删除旧数据（两表 + H204 è§„则审核结果）
        energyMapper.delete(new LambdaQueryWrapper<EnergyVehicleQuarterly>()
            .eq(EnergyVehicleQuarterly::getReportPeriod, period));
        energyAuthMapper.delete(new LambdaQueryWrapper<EnergyAuthVehicle>()
            .eq(EnergyAuthVehicle::getReportPeriod, period));
        List<Long> h204RuleIds = new ArrayList<>();
        for (com.trafficaudit.rulemanage.entity.AuditRule rule : ruleMapper.selectList(null)) {
            if ("H204".equals(rule.getReportType())) h204RuleIds.add(rule.getId());
        }
        if (!h204RuleIds.isEmpty()) {
            auditResultMapper.delete(new LambdaQueryWrapper<AuditResult>()
                .eq(AuditResult::getReportPeriod, period)
                .in(AuditResult::getRuleId, h204RuleIds));
        }

        int success = 0;
        List<String> failDetails = new ArrayList<>();
        for (EnergyRow item : rows) {
            try {
                energyMapper.insert(item.entity);
                success++;
            } catch (Exception e) {
                Throwable cause = e;
                while (cause.getCause() != null) cause = cause.getCause();
                String reason = cause.getMessage();
                if (reason == null || reason.trim().isEmpty()) reason = e.getMessage();
                failDetails.add("第 " + item.excelRow + " è¡Œï¼ˆ" + item.entity.getEnterpriseName()
                    + " " + item.entity.getPlateNo() + "）：" + reason);
                log.error("Energy insert error: row {}, {}", item.excelRow, item.entity.getPlateNo(), e);
            }
        }
        String errorDetail = String.join("\n", failDetails);
        if (errorDetail.length() > 4000) {
            errorDetail = errorDetail.substring(0, 4000) + "\n……";
        }
        recordBatch(file.getOriginalFilename(), "H204", period, rows.size(), success, failDetails.size(), errorDetail);

        int authSuccess = 0;
        for (EnergyAuthVehicle auth : authList) {
            try {
                energyAuthMapper.insert(auth);
                authSuccess++;
            } catch (Exception e) {
                log.error("energy auth insert error: {}", auth.getPlateNo(), e);
            }
        }
        recordBatch(file.getOriginalFilename(), "ENERGY_AUTH", period, authList.size(), authSuccess, 0, null);
        log.info("Energy monthly imported: {} vehicles, auth {} rows for {}", success, authSuccess, period);
        return new ImportResult(success, failDetails.size(), failDetails);
    }

    /** èƒ½è€—车辆运政信息（独立模板：车牌号/车辆类型/燃料类型/标记吨位/准牵引质量） */
    public ImportResult importEnergyAuth(MultipartFile file, String period) throws Exception {
        List<EnergyAuthVehicle> authList = new ArrayList<>();
        try (Workbook wb = WorkbookFactory.create(file.getInputStream())) {
            Sheet sheet = wb.getSheetAt(0);
            for (int r = 1; r <= sheet.getLastRowNum(); r++) {
                Row row = sheet.getRow(r);
                if (row == null) continue;
                String plate = getString(row, 0);
                if (plate == null || plate.trim().isEmpty()) continue;
                EnergyAuthVehicle auth = new EnergyAuthVehicle();
                auth.setReportPeriod(period);
                auth.setPlateNo(plate.trim());
                auth.setVehicleType(getString(row, 1));
                auth.setFuelType(getString(row, 2));
                auth.setMarkedTonnage(getDecimal(row, 3));
                auth.setTractionQuality(getDecimal(row, 4));
                authList.add(auth);
            }
        } catch (Exception e) {
            log.error("Energy auth parse error", e);
            throw e;
        }
        // å¹‚等：同报表期重新导入，先删除旧数据
        energyAuthMapper.delete(new LambdaQueryWrapper<EnergyAuthVehicle>()
            .eq(EnergyAuthVehicle::getReportPeriod, period));
        deleteRuleResults("H204", period);
        int success = 0;
        List<String> failDetails = new ArrayList<>();
        for (EnergyAuthVehicle auth : authList) {
            try {
                energyAuthMapper.insert(auth);
                success++;
            } catch (Exception e) {
                Throwable cause = e;
                while (cause.getCause() != null) cause = cause.getCause();
                String reason = cause.getMessage();
                if (reason == null || reason.trim().isEmpty()) reason = e.getMessage();
                failDetails.add("第 " + (authList.indexOf(auth) + 2) + " è¡Œï¼ˆ" + auth.getPlateNo() + "）：" + reason);
                log.error("Energy auth insert error: {}", auth.getPlateNo(), e);
            }
        }
        String errorDetail = String.join("\n", failDetails);
        if (errorDetail.length() > 4000) errorDetail = errorDetail.substring(0, 4000) + "\n……";
        recordBatch(file.getOriginalFilename(), "ENERGY_AUTH", period, authList.size(), success, failDetails.size(), errorDetail);
        log.info("Energy auth imported: {} rows for {}", success, period);
        return new ImportResult(success, failDetails.size(), failDetails);
    }

    /** H204 è¡Œè®°å½•ï¼šä¿ç•™ Excel è¡Œå·ç”¨äºŽå¤±è´¥å®šä½ */
    private static class EnergyRow {
        final int excelRow;
        final EnergyVehicleQuarterly entity;

        EnergyRow(int excelRow, EnergyVehicleQuarterly entity) {
            this.excelRow = excelRow;
            this.entity = entity;
        }
    }

    /** ç©ºå•å…ƒæ ¼è¿”回 null（用于能耗明细未填写项与 0 åŒºåˆ†ï¼‰ */
    private Integer getIntOrNull(Row row, int idx) {
        Double val = getDecimalOrNull(row, idx);
        return val == null ? null : val.intValue();
    }

    // ========== è¿æ”¿è½¦è¾† ==========

@@ -601,6 +1139,19 @@
        }
    }

    /** æ•°æ®å˜åŒ–后删除指定报表类型指定报表期的审核结果（需重新执行审核） */
    private void deleteRuleResults(String reportType, String period) {
        List<Long> ruleIds = new ArrayList<>();
        for (com.trafficaudit.rulemanage.entity.AuditRule rule : ruleMapper.selectList(null)) {
            if (reportType.equals(rule.getReportType())) ruleIds.add(rule.getId());
        }
        if (!ruleIds.isEmpty()) {
            auditResultMapper.delete(new LambdaQueryWrapper<AuditResult>()
                .eq(AuditResult::getReportPeriod, period)
                .in(AuditResult::getRuleId, ruleIds));
        }
    }

    /** æŒ‰è¡¨å¤´åç§°å»ºç«‹åˆ—号映射，兼容新旧模板列位差异 */
    private Map<String, Integer> buildHeaderMap(Row header) {
        Map<String, Integer> colMap = new HashMap<>();
@@ -662,10 +1213,26 @@
        }
    }

    private static class PassengerRow {
        int excelRow;
        PassengerEnterpriseMonthly entity;

        PassengerRow(int excelRow, PassengerEnterpriseMonthly entity) {
            this.excelRow = excelRow;
            this.entity = entity;
        }
    }


    private String getString(Row row, int idx) {
        Cell cell = row.getCell(idx);
        if (cell == null) return null;
        // å…¬å¼å•å…ƒæ ¼ï¼šè¯»ç¼“存字符串（.et/WPS æ–‡ä»¶å¸¸è§ï¼ŒDataFormatter æ—  evaluator æ—¶åªè¿”回公式文本）
        if (cell.getCellType() == CellType.FORMULA && cell.getCachedFormulaResultType() == CellType.STRING) {
            String cached = cell.getStringCellValue();
            cached = cached == null ? null : cached.trim();
            return cached == null || cached.isEmpty() ? null : cached;
        }
        String val = FORMATTER.formatCellValue(cell).trim();
        return val.isEmpty() ? null : val;
    }
@@ -675,6 +1242,10 @@
        if (cell == null) return 0.0;
        // æ•°å€¼å•å…ƒæ ¼ç›´æŽ¥å–原始值，避免被 Excel æ˜¾ç¤ºæ ¼å¼ï¼ˆç™¾åˆ†æ¯”/0_ ç­‰ï¼‰å½±å“è§£æž
        if (cell.getCellType() == CellType.NUMERIC) {
            return cell.getNumericCellValue();
        }
        // å…¬å¼å•å…ƒæ ¼ï¼šè¯»ç¼“存数值（.et/WPS è·¨è¡¨å…¬å¼å¸¸è§ï¼ŒDataFormatter æ—  evaluator æ—¶åªè¿”回公式文本）
        if (cell.getCellType() == CellType.FORMULA && cell.getCachedFormulaResultType() == CellType.NUMERIC) {
            return cell.getNumericCellValue();
        }
        String val = FORMATTER.formatCellValue(cell).trim();
@@ -699,6 +1270,9 @@
        if (cell.getCellType() == CellType.NUMERIC) {
            return cell.getNumericCellValue();
        }
        if (cell.getCellType() == CellType.FORMULA && cell.getCachedFormulaResultType() == CellType.NUMERIC) {
            return cell.getNumericCellValue();
        }
        String val = FORMATTER.formatCellValue(cell).trim();
        if (val.isEmpty()) return null;
        try {
@@ -707,4 +1281,1347 @@
            return null;
        }
    }
    // ========== æŠ•èµ„模块（客运站场 / ç‰©æµå›­åŒºï¼Œå…¨çœæ±‡æ€»å¤§è¡¨ï¼‰ ==========

    /** äº¿å…ƒæŠ•èµ„项目固定名单（2026年规上项目表） */
    private static final java.util.Set<String> INVEST_BILLION_NAMES = new LinkedHashSet<>(Arrays.asList(
        "汉口客运中心", "钟祥市综合交通客运枢纽一期项目", "航发智慧物流园", "国胜公路港",
        "十堰生产服务型国家物流枢纽工程项目", "秭归县脐橙产业综合物流中心", "宜都供销商贸物流园",
        "长阳县城乡冷链物流园", "宜昌港兴山港区管公水多式联运建设项目", "玉湖冷链（襄阳）交易中心项目",
        "武汉万吨华中冷链港二期项目", "湖北长江现代物流产业集聚示范区·现代物流园",
        "鄂州花湖国际机场空港型国家物流枢纽智慧公共国际货站项目", "荆门智慧冷链物流园",
        "荆门北站顺洋物流基地（荆门北子陵铁路物流园）", "沙洋多式联运现代物流园一期（沙洋煤炭储备•集装箱散改集基地）",
        "首衡城智慧冷链物流二期项目G区", "孝昌广浔智慧物流电商产业园", "申通（孝感）智慧物流电商产业园（三期）",
        "公安县多式联运综合物流园", "荆州市铁水联运物流中心", "荆州市瑞海国际物流园一期", "荆州经开区智能仓储物流园项目",
        "鄂东（黄冈）数智物流综合服务中心",
        "鄂湘赣商贸物流中心一期（通城县物流配送中心、鄂南智慧物流产业园建设、鄂南智慧物流产业园建设项目（二期）、冷链配送中心）项目",
        "咸宁国际陆港物流园-咸宁市国际陆港综合物流园（一期）", "咸宁国际陆港物流园-新建咸宁铁路物流基地项目",
        "崇阳县综合物流园及配套设施建设项目", "恩施七里坪物流园", "职业工装产业集聚区仓储物流项目",
        "极兔速递华中物流枢纽基地项目", "湖北迈睿达供应链总部研发及生产基地项目", "东楚航空冷链物流中心",
        "三峡智慧航空物流产业园", "汉江襄阳（小河）港多式联运物流园", "宏茂全球通运项目", "武汉天河综合客运枢纽",
        "广水市杨家寨公铁物流园项目---广水市杨寨铁路货场（广水市华鑫冶金物流货场）", "阳新综合客运枢纽站",
        "当阳市高铁综合客运站", "宜昌北客运站", "南漳县公铁换乘中心(郑万高铁南漳综合客运枢纽)", "京山南公铁综合客运枢纽",
        "沿江高铁汉川北站站前广场(综合客运枢纽)", "武杭高铁黄冈西综合客运枢纽", "黄黄高铁浠水综合客运枢纽",
        "郑万高铁巴东综合客运枢纽", "中通供应链湖北管理中心项目", "阳逻港铁水联运二期中欧班列集结中心",
        "西马国际（黄石）智慧物流园", "十堰市城发仓储物流中心", "枝江市顾家店仓储物流中心（一期）", "三峡建材物流园",
        "宜都市陆城综合物流运输廊道", "宜昌传化公路港二期", "武汉港航襄阳智慧物流园", "谷城县城乡智慧仓储物流产业园",
        "九州通沃田国际供应链中心项目", "湖北恒峰国际物流园", "湖北中青供应链有限公司包装配套、仓储运输项目",
        "大悟县电商物流产业园", "安陆市城乡冷链物流配送中心", "大别山智慧物流产业园", "武穴市供销社集采集配综合服务中心工程",
        "罗田县综合物流园", "黑豹国际物流园（黄冈综合园区）", "麻城市农产品综合物流园", "巴东经济开发区青龙桥智慧物流产业园",
        "鹤峰武陵山仓储物流园", "咸丰县综合物流园", "宣恩县寄递物流园", "来凤县龙凤物流园交通物流中心",
        "仙桃国家高新区物流枢纽中心建设项目", "天门市物流中心建设项目"));

    /** ç»æµŽå¼ºåŽ¿é¡¹ç›®å›ºå®šåå• */
    private static final java.util.Set<String> INVEST_COUNTY_NAMES = new LinkedHashSet<>(Arrays.asList(
        "西马国际（黄石）智慧物流园", "黄石大冶湖高新区智慧冷链物流园", "大冶湖高新智慧物流港项目（城西北供应链服务中心）",
        "秭归县脐橙产业综合物流中心", "宜都供销商贸物流园", "长阳县城乡冷链物流园及其配套设施建设项目",
        "宜昌港兴山港区管公水多式联运建设项目", "枝江市顾家店仓储物流中心（一期）", "宜都市陆城综合物流运输廊道",
        "老河口市农产品仓储物流交易中心建设项目", "谷城县城乡智慧仓储物流产业园", "沙洋多式联运现代物流园",
        "大悟县电商物流产业园", "应城市智慧冷链仓储物流园", "孝昌广浔智慧物流电商产业园建设项目", "安陆市城乡冷链物流配送中心",
        "松滋市星络物流园", "公安县多式联运综合物流园", "中国供销公安商贸物流园（公安县域集采集配中心）", "同洲智慧物流园",
        "大别山智慧物流产业园", "武穴市供销社集采集配综合服务中心工程", "罗田县综合物流园", "鄂东（黄冈）数智物流综合服务中心",
        "麻城市农产品综合物流园", "鄂湘赣商贸物流中心（一期）", "嘉鱼县智慧交通物流枢纽中心",
        "崇阳县国家级综合物流枢纽及配套设施建设项目", "康华智慧物流园", "综合物流园（湖北交投随州智慧供应链产业园）",
        "巴东经济开发区青龙桥智慧物流产业园", "恩施市七里坪物流园", "鹤峰武陵山仓储物流园", "咸丰县综合物流园",
        "来凤县龙凤物流园交通物流中心", "宣恩县寄递物流园", "仙桃国家高新区物流枢纽中心建设项目",
        "职业工装产业集聚区仓储物流项目", "中国虾谷冷链仓储物流园", "天门市物流中心建设项目", "神农架物流园"));

    /** "十五五"重点物流项目固定名单 */
    private static final java.util.Set<String> INVEST_FIVE_YEAR_NAMES = new LinkedHashSet<>(Arrays.asList(
        "航发智慧物流园", "中通供应链湖北管理中心项目", "阳逻港铁水联运二期中欧班列集结中心", "极兔速递华中物流枢纽基地项目",
        "中欧班列配套多式联运中转中心项目", "新开发银行贷款长江中游（武汉）智慧物流枢纽项目铁路工业站子项",
        "黄石新港国胜智慧公路港项目", "十堰生产服务型国家物流枢纽工程项目", "十堰市城发仓储物流中心",
        "寿康永乐智能化物流设备升级改造", "十堰汽配（广场）物流中心扩能升级项目", "十堰武当山机场航空物流园项目",
        "丹江口市陈家港铁水公空联运基地", "长阳县城乡冷链物流园及其配套设施建设项目", "三峡建材物流园",
        "宜都市陆城综合物流运输廊道", "三峡智慧航空物流产业园", "当阳市坝陵化工园区综合物流园", "远安县物流中心提能升级项目",
        "宜昌市智慧物流集散中心", "宜都市枝城多式联运临港物流园", "玉湖冷链（襄阳）交易中心项目", "传化鄂西北智慧物流中心项目",
        "武汉港航襄阳智慧物流园", "唐白河港散货转运中心项目", "汉江襄阳（小河）港多式联运物流园", "襄州区大宗商品多式联运交易中心",
        "综合性供应链产业园区（中国有机谷供应链智慧产业园、谷城智慧冷链物流供应链产业园）", "南漳县现代智能物流园区",
        "湖北长江现代物流产业集聚示范区·现代物流园", "弘业现代物流产业园", "宏茂全球通运项目", "沙洋多式联运现代物流园",
        "京山市公铁物流中心", "新材料工业品智慧物流园", "长荆铁路（钟祥）公铁联运集装箱物流园", "屈家岭智慧物流园",
        "东方冷链智慧物流配送中心", "应城市智慧冷链仓储物流园", "孝昌广浔智慧物流电商产业园建设项目",
        "京汉粤大通道孝感国家综合货运枢纽", "公安县多式联运综合物流园", "荆州经开区智能仓储物流园项目",
        "中国供销公安商贸物流园（公安县域集采集配中心）", "监利市港口物流园（城区园）", "鄂东（黄冈）数智物流综合服务中心",
        "崇阳县国家级综合物流枢纽及配套设施建设项目", "咸宁高新区冻库冷链项目（一期）", "咸安区数字物流产业园及基础设施建设项目",
        "通山县特色农产品现代物流基地建设项目", "赤壁沿江公铁联运绿色物流中心项目", "咸宁城乡智慧物流园",
        "综合物流园（湖北交投随州智慧供应链产业园）", "随州综合仓储配送中心",
        "广水市杨家寨公铁物流园项目---第一期广水市杨寨铁路货场（广水市华鑫冶金物流货场）",
        "巴东经济开发区青龙桥智慧物流产业园", "鹤峰武陵山仓储物流园", "咸丰县综合物流园",
        "仙桃国家高新区物流枢纽中心建设项目", "天门市域公共综合物流园", "潜江市农产品现代物流基础设施建设项目",
        "潜江现代农业科技示范园冷链物流中心项目", "湖北潜电物流有限公司现代物流中心（一、二、三期）"));

    /** æ±‡æ€»å¤§è¡¨å¸‚州短名 -> è§„范名 */
    private static final Map<String, String> INVEST_CITY_SHORT_TO_FULL = new LinkedHashMap<>();

    static {
        INVEST_CITY_SHORT_TO_FULL.put("武汉", "武汉市");
        INVEST_CITY_SHORT_TO_FULL.put("黄石", "黄石市");
        INVEST_CITY_SHORT_TO_FULL.put("十堰", "十堰市");
        INVEST_CITY_SHORT_TO_FULL.put("宜昌", "宜昌市");
        INVEST_CITY_SHORT_TO_FULL.put("襄阳", "襄阳市");
        INVEST_CITY_SHORT_TO_FULL.put("鄂州", "鄂州市");
        INVEST_CITY_SHORT_TO_FULL.put("荆门", "荆门市");
        INVEST_CITY_SHORT_TO_FULL.put("孝感", "孝感市");
        INVEST_CITY_SHORT_TO_FULL.put("荆州", "荆州市");
        INVEST_CITY_SHORT_TO_FULL.put("黄冈", "黄冈市");
        INVEST_CITY_SHORT_TO_FULL.put("咸宁", "咸宁市");
        INVEST_CITY_SHORT_TO_FULL.put("随州", "随州市");
        INVEST_CITY_SHORT_TO_FULL.put("恩施", "恩施州");
        INVEST_CITY_SHORT_TO_FULL.put("仙桃", "仙桃市");
        INVEST_CITY_SHORT_TO_FULL.put("潜江", "潜江市");
        INVEST_CITY_SHORT_TO_FULL.put("天门", "天门市");
        INVEST_CITY_SHORT_TO_FULL.put("林区", "神农架林区");
    }

    /**
     * æŠ•èµ„月报导入（全省汇总大表）。
     * category: å®¢è¿ç«™åœºï¼ˆxlsx æ˜Žç»† sheet）/ ç‰©æµå›­åŒºï¼ˆxls åˆ†é¡¹ç›®æŠ•èµ„完成情况 sheet）
     * å¹‚等：同报表期旧月度数据与 INVEST å®¡æ ¸ç»“果先删，项目主档按 é¡¹ç›®å+类别 upsert。
     */
    public ImportResult importInvestment(MultipartFile file, String period, String category) throws Exception {
        boolean passenger = "客运站场".equals(category);
        List<InvestRow> rows = new ArrayList<>();
        List<String> cityOrder = new ArrayList<>();
        String currentCity = null;
        try (Workbook wb = WorkbookFactory.create(file.getInputStream())) {
            Sheet sheet = pickInvestmentSheet(wb, passenger);
            // å®šä½è¡¨å¤´è¡Œï¼šåŒ…含"项目名称"且其后有数据
            int headerRow = -1;
            for (int r = 0; r <= Math.min(sheet.getLastRowNum(), 8); r++) {
                Row row = sheet.getRow(r);
                if (row == null) continue;
                String a = getString(row, 0);
                String b = getString(row, 1);
                if (b != null && b.contains("项目名称") && (a == null || a.contains("序号") || a.contains("序"))) {
                    headerRow = r;
                    break;
                }
            }
            if (headerRow < 0) {
                throw new RuntimeException("未找到表头行（需包含 åºå·/项目名称 åˆ—）");
            }
            for (int r = headerRow + 1; r <= sheet.getLastRowNum(); r++) {
                Row row = sheet.getRow(r);
                if (row == null) continue;
                String a = getString(row, 0);
                String b = getString(row, 1);
                if (a == null || a.trim().isEmpty()) {
                    if (b == null || b.trim().isEmpty()) continue;
                }
                String aTrim = a == null ? "" : a.trim();
                String bTrim = b == null ? "" : b.trim();
                // åˆè®¡/标题行
                if (aTrim.contains("合计") || aTrim.contains("总计")) continue;
                // èµ„金类别/分组标题行（一、二、三、四、…）
                if (aTrim.matches("^[一二三四五六七八九十]+、.*")) continue;
                // å¸‚州小节行
                String city = investmentCity(aTrim);
                if (city != null) {
                    currentCity = city;
                    if (!cityOrder.contains(city)) cityOrder.add(city);
                    continue;
                }
                // é¡¹ç›®è¡Œï¼šåºå·ä¸ºæ•°å­—且项目名非空
                boolean seqNum = aTrim.matches("\\d+(\\.\\d+)?");
                if (seqNum && !bTrim.isEmpty()) {
                    InvestmentProject project = new InvestmentProject();
                    project.setProjectName(bTrim);
                    project.setCategory(category);
                    project.setCity(currentCity);
                    project.setBuilderName(getString(row, 2));
                    project.setConstructNature(getString(row, 3));
                    project.setStartTime(investTime(getString(row, 4)));
                    project.setEndTime(investTime(getString(row, 5)));
                    project.setTotalInvestment(getDecimal(row, 6));
                    project.setApprovalGk(getString(row, 18));
                    project.setApprovalCs(getString(row, 19));
                    project.setSource("全省汇总大表");
                    project.setIsBillion(INVEST_BILLION_NAMES.contains(bTrim) ? 1 : 0);
                    project.setIsCounty(INVEST_COUNTY_NAMES.contains(bTrim) ? 1 : 0);
                    project.setIsFiveYear(INVEST_FIVE_YEAR_NAMES.contains(bTrim) ? 1 : 0);

                    InvestmentMonthly monthly = new InvestmentMonthly();
                    monthly.setReportPeriod(period);
                    monthly.setYearPlan(getDecimal(row, 8));
                    monthly.setYearCum(getDecimal(row, 9));
                    monthly.setMonthDone(getDecimal(row, 10));
                    monthly.setStartCum(getDecimal(row, 7));
                    monthly.setProgressStage(getString(row, 11));
                    monthly.setProgressDesc(getString(row, 12));
                    monthly.setBuildingArea(getDecimalOrNull(row, 15));
                    rows.add(new InvestRow(r + 1, project, monthly));
                }
            }
        } catch (Exception e) {
            log.error("Investment import parse error: {}", category, e);
            throw e;
        }

        // å¹‚等清理：同报表期、同类别月度数据 + INVEST å®¡æ ¸ç»“果（项目主档跨月保留，按名 upsert）
        List<InvestmentProject> sameCat = investProjectMapper.selectList(
            new LambdaQueryWrapper<InvestmentProject>().eq(InvestmentProject::getCategory, category));
        java.util.Set<Long> catProjectIds = new HashSet<>();
        for (InvestmentProject pc : sameCat) catProjectIds.add(pc.getId());
        if (!catProjectIds.isEmpty()) {
            investMonthlyMapper.delete(new LambdaQueryWrapper<InvestmentMonthly>()
                .eq(InvestmentMonthly::getReportPeriod, period)
                .in(InvestmentMonthly::getProjectId, catProjectIds));
        }
        List<Long> investRuleIds = new ArrayList<>();
        for (com.trafficaudit.rulemanage.entity.AuditRule rule : ruleMapper.selectList(null)) {
            if ("INVEST".equals(rule.getReportType())) investRuleIds.add(rule.getId());
        }
        if (!investRuleIds.isEmpty()) {
            auditResultMapper.delete(new LambdaQueryWrapper<AuditResult>()
                .eq(AuditResult::getReportPeriod, period)
                .in(AuditResult::getRuleId, investRuleIds));
        }

        int success = 0;
        List<String> failDetails = new ArrayList<>();
        for (InvestRow item : rows) {
            try {
                // ä¸»æ¡£ upsert（按 é¡¹ç›®å+类别）
                InvestmentProject exist = investProjectMapper.selectOne(new LambdaQueryWrapper<InvestmentProject>()
                    .eq(InvestmentProject::getProjectName, item.project.getProjectName())
                    .eq(InvestmentProject::getCategory, category)
                    .last("LIMIT 1"));
                if (exist == null) {
                    investProjectMapper.insert(item.project);
                    item.monthly.setProjectId(item.project.getId());
                } else {
                    item.project.setId(exist.getId());
                    item.project.setCreatedAt(exist.getCreatedAt());
                    investProjectMapper.updateById(item.project);
                    item.monthly.setProjectId(exist.getId());
                }
                investMonthlyMapper.insert(item.monthly);
                success++;
            } catch (Exception e) {
                Throwable cause = e;
                while (cause.getCause() != null) cause = cause.getCause();
                String reason = cause.getMessage();
                if (reason == null || reason.trim().isEmpty()) reason = e.getMessage();
                failDetails.add("第 " + item.excelRow + " è¡Œï¼ˆ" + item.project.getProjectName() + "）：" + reason);
                log.error("Investment insert error: row {}", item.excelRow, e);
            }
        }
        String errorDetail = String.join("\n", failDetails);
        if (errorDetail.length() > 4000) errorDetail = errorDetail.substring(0, 4000) + "\n……";
        recordBatch(file.getOriginalFilename(), "INVEST_" + category, period, rows.size(), success, failDetails.size(), errorDetail);
        log.info("Investment {} imported: {} rows for {}", category, success, period);
        return new ImportResult(success, failDetails.size(), failDetails);
    }

    // ========== æŠ•èµ„模块 M2：市州单表批量导入（容错解析） ==========

    /**
     * å¸‚州单表批量导入：扫描 docs/投资/输入/{类别目录}/{X月} ä¸‹å…¨éƒ¨ xls/xlsx/et（跳过 pdf），
     * å®¹é”™è§£æžæ¯ä¸ªæ–‡ä»¶ï¼ˆå®šä½è¡¨å¤´è¡Œ + åˆ—名映射），upsert é¡¹ç›®ä¸»æ¡£ + å†™å…¥æœˆåº¦ï¼Œ
     * å¹¶ä¸Žã€Œåäº”五」模板清单规范化匹配后标记 is_five_year。
     */
    public Map<String, Object> importInvestCityDir(String period, String category) throws Exception {
        boolean passenger = "客运站场".equals(category);
        String catDir = passenger ? "客运（客运站）" : "物流（物流园区）";
        String monthDir = investMonthDir(period);
        if (monthDir.isEmpty()) throw new RuntimeException("报表期格式应为 yyyy-MM，例如 2026-07");
        File dir = resolveInvestInputDir(catDir, monthDir);
        if (dir == null || !dir.isDirectory()) {
            throw new RuntimeException("未找到市州单表目录：docs/投资/输入/" + catDir + "/" + monthDir);
        }
        Set<String> fiveYearNames = loadFiveYearProjectNames();
        List<InvestCityRow> rows = new ArrayList<>();
        List<Map<String, Object>> fileResults = new ArrayList<>();
        File[] files = dir.listFiles((d, n) -> {
            String lower = n.toLowerCase();
            return lower.endsWith(".xls") || lower.endsWith(".xlsx") || lower.endsWith(".et");
        });
        if (files == null || files.length == 0) {
            throw new RuntimeException("目录中没有可解析的报表文件（xls/xlsx/et）：" + dir.getAbsolutePath());
        }
        Arrays.sort(files, Comparator.comparing(File::getName));
        for (File f : files) {
            Map<String, Object> fr = new LinkedHashMap<>();
            fr.put("fileName", f.getName());
            try (java.io.InputStream is = new java.io.FileInputStream(f);
                 Workbook wb = WorkbookFactory.create(is)) {
                parseInvestCityWorkbook(wb, f.getName(), category, period, fiveYearNames, rows, fr);
            } catch (Exception e) {
                fr.put("success", 0);
                fr.put("error", e.getMessage() == null ? e.toString() : e.getMessage());
                log.error("invest city file parse error: {}", f.getName(), e);
            }
            fileResults.add(fr);
        }
        // å¹‚等清理：同类别同报表期月度数据 + INVEST å®¡æ ¸ç»“果（项目主档跨月保留，按名 upsert）
        cleanInvestMonthly(category, period);
        int success = 0;
        List<String> failDetails = new ArrayList<>();
        for (InvestCityRow item : rows) {
            try {
                saveInvestProjectRow(item.project, item.monthly);
                success++;
            } catch (Exception e) {
                Throwable cause = e;
                while (cause.getCause() != null) cause = cause.getCause();
                String reason = cause.getMessage();
                if (reason == null || reason.trim().isEmpty()) reason = e.getMessage();
                failDetails.add(item.fileName + " ç¬¬ " + item.excelRow + " è¡Œï¼ˆ" + item.project.getProjectName() + "）：" + reason);
                log.error("Invest city insert error: file {}, row {}", item.fileName, item.excelRow, e);
            }
        }
        String errorDetail = String.join("\n", failDetails);
        if (errorDetail.length() > 4000) errorDetail = errorDetail.substring(0, 4000) + "\n……";
        recordBatch("市州单表批量导入（" + catDir + "/" + monthDir + "）", "INVEST_" + category + "_CITY",
            period, rows.size(), success, failDetails.size(), errorDetail);
        int fiveYearMatched = 0;
        for (InvestCityRow item : rows) {
            if (Integer.valueOf(1).equals(item.project.getIsFiveYear())) fiveYearMatched++;
        }
        Map<String, Object> result = new LinkedHashMap<>();
        result.put("total", rows.size());
        result.put("success", success);
        result.put("fail", failDetails.size());
        result.put("failDetails", failDetails);
        result.put("files", fileResults);
        result.put("fiveYearTemplateProjects", fiveYearNames.size());
        result.put("fiveYearMatched", fiveYearMatched);
        log.info("Invest city {} {} imported: {} rows (fiveYear matched {}/{})",
            category, period, success, fiveYearMatched, fiveYearNames.size());
        return result;
    }

    /** å¤š sheet åŽ†å²æ–‡ä»¶ï¼ˆè¥„阳 .et ç­‰ï¼‰ï¼šsheet åå«æŠ¥è¡¨æœŸä¼˜å…ˆï¼Œå…¶æ¬¡é€‰æ•°æ®è¡Œæœ€å¤š */
    private boolean investSheetMatchesPeriod(Sheet sh, String period) {
        if (period == null || !period.matches("\\d{4}-\\d{2}")) return false;
        String name = sh.getSheetName();
        if (name == null || name.isEmpty()) return false;
        String norm = name.replace(" ", "");
        int month = Integer.parseInt(period.substring(5, 7));
        return norm.contains(month + "月") || norm.contains(String.format("%02d", month) + "月")
            || name.contains(period) || name.contains(period.replace("-0", "-"));
    }

    /** è§£æžå•ä¸ªå¸‚州报表：选 sheet（报表期名优先 + æ•°æ®è¡Œæ•°ï¼‰ï¼ŒæŒ‰åˆ—名映射提取项目行 */
    private void parseInvestCityWorkbook(Workbook wb, String fileName, String category, String period,
                                         Set<String> fiveYearNames, List<InvestCityRow> rows, Map<String, Object> fr) {
        Sheet best = null;
        Map<String, Integer> bestCol = null;
        int bestScore = -1;
        for (int i = 0; i < wb.getNumberOfSheets(); i++) {
            Sheet sh = wb.getSheetAt(i);
            Map<String, Integer> col = findInvestHeader(sh);
            if (col == null) continue;
            int cnt = countInvestRows(sh, col);
            int score = cnt + (cnt > 0 && investSheetMatchesPeriod(sh, period) ? 1000000 : 0);
            if (score > bestScore) {
                best = sh;
                bestCol = col;
                bestScore = score;
            }
        }
        if (best == null) {
            fr.put("success", 0);
            fr.put("error", "未找到含「项目名称」的表头");
            return;
        }
        String city = cityFromFileName(fileName);
        if (city == null) city = cityFromSheetHeader(best);
        String currentCity = city;
        Map<String, Integer> col = bestCol;
        int nameCol = col.get("name");
        boolean hasSeq = col.containsKey("seq");
        int seqCol = hasSeq ? col.get("seq") : 0;
        int parsed = 0;
        for (int r = col.get("headerRow") + 1; r <= best.getLastRowNum(); r++) {
            Row row = best.getRow(r);
            if (row == null) continue;
            String name = cellStr(row, nameCol);
            if (name == null || name.trim().isEmpty()) continue;
            String nt = name.trim().replaceAll("[\r\n]+", "");
            if (nt.contains("合计") || nt.contains("总计")) continue;
            if (nt.matches("^[一二三四五六七八九十]+、.*")) continue;
            if (nt.matches("^（[一二三四五六七八九十]+）.*")) continue;
            if (nt.replace(" ", "").matches(".*小\\s*计.*")) continue;
            if (nt.startsWith("填报") || nt.startsWith("单位负责人") || nt.matches("^\\d+、.*")) continue;
            if (hasSeq) {
                String seq = cellStr(row, seqCol);
                if (seq == null || seq.trim().isEmpty()) {
                    // å¸‚州小节行（如 "武汉" "天 é—¨"），更新当前市州
                    String c = investmentCity(nt);
                    if (c != null) currentCity = c;
                    continue;
                }
                if (!seq.trim().matches("\\d+(\\.\\d+)?")) continue;
            } else {
                // æ— åºå·åˆ—（随州等）：项目名非空即项目行，市州小节行用 investmentCity è¯†åˆ«
                String c = investmentCity(nt);
                if (c != null) { currentCity = c; continue; }
            }
            InvestmentProject project = new InvestmentProject();
            project.setProjectName(nt);
            project.setCategory(category);
            project.setCity(currentCity);
            project.setBuilderName(cellStr(row, col.get("builder")));
            project.setConstructNature(cellStr(row, col.get("nature")));
            project.setStartTime(investTime(cellStr(row, col.get("start"))));
            project.setEndTime(investTime(cellStr(row, col.get("end"))));
            project.setTotalInvestment(cellNum(row, col.get("total")));
            project.setApprovalGk(cellStr(row, col.get("gk")));
            project.setApprovalCs(cellStr(row, col.get("cs")));
            project.setBuildingArea(cellNumOrNull(row, col.get("area")));
            project.setSource("市州单表");
            project.setIsBillion(INVEST_BILLION_NAMES.contains(nt) ? 1 : 0);
            project.setIsCounty(INVEST_COUNTY_NAMES.contains(nt) ? 1 : 0);
            project.setIsFiveYear(fiveYearNames.contains(normalizeProjectName(nt)) ? 1 : 0);
            InvestmentMonthly monthly = new InvestmentMonthly();
            monthly.setReportPeriod(period);
            monthly.setStartCum(cellNum(row, col.get("startcum")));
            monthly.setYearPlan(cellNum(row, col.get("yearplan")));
            monthly.setYearCum(cellNum(row, col.get("yearcum")));
            monthly.setMonthDone(cellNum(row, col.get("monthdone")));
            monthly.setProgressStage(cellStr(row, col.get("stage")));
            monthly.setProgressDesc(cellStr(row, col.get("desc")));
            monthly.setBuildingArea(cellNumOrNull(row, col.get("area")));
            rows.add(new InvestCityRow(r + 1, fileName, project, monthly));
            parsed++;
        }
        fr.put("city", currentCity);
        fr.put("success", parsed);
    }

    /** å®šä½å«ã€Œé¡¹ç›®åç§°ã€çš„表头行并按列名关键词建立列映射（支持双层表头合并） */
    private Map<String, Integer> findInvestHeader(Sheet sh) {
        int maxHeaderRow = Math.min(22, sh.getLastRowNum());
        for (int r = 0; r <= maxHeaderRow; r++) {
            Row row = sh.getRow(r);
            if (row == null) continue;
            boolean hasName = false;
            for (int c = 0; c <= row.getLastCellNum(); c++) {
                String v = cellStr(row, c);
                if (v != null && v.contains("项目名称")) { hasName = true; break; }
            }
            if (!hasName) continue;
            Map<Integer, String> colTexts = new HashMap<>();
            for (int rr = r; rr <= Math.min(r + 3, sh.getLastRowNum()); rr++) {
                Row rr2 = sh.getRow(rr);
                if (rr2 == null) continue;
                for (int c = 0; c <= rr2.getLastCellNum(); c++) {
                    String v = cellStr(rr2, c);
                    if (v == null) continue;
                    colTexts.merge(c, v, (a, b) -> a + "|" + b);
                }
            }
            Map<String, Integer> col = new HashMap<>();
            for (Map.Entry<Integer, String> e : colTexts.entrySet()) {
                int c = e.getKey();
                String v = e.getValue();
                if (v.contains("项目名称")) col.putIfAbsent("name", c);
                else if (v.contains("投资建设") || v.contains("建设单位") || v.contains("项目业主")) col.putIfAbsent("builder", c);
                else if (v.contains("建设性质")) col.putIfAbsent("nature", c);
                else if (v.contains("开工")) col.putIfAbsent("start", c);
                else if (v.contains("竣工") || v.contains("建成")) col.putIfAbsent("end", c);
                else if ((v.contains("计划总投资") || v.contains("总投资")) && !v.contains("累计")) col.putIfAbsent("total", c);
                else if (v.contains("自开始建设")) col.putIfAbsent("startcum", c);
                else if (v.contains("本年计划")) col.putIfAbsent("yearplan", c);
                else if (v.contains("自年初累计")) col.putIfAbsent("yearcum", c);
                else if (v.contains("本月完成")) col.putIfAbsent("monthdone", c);
                else if (v.contains("建设阶段")) col.putIfAbsent("stage", c);
                else if (v.contains("形象进度")) col.putIfAbsent("desc", c);
                else if (v.contains("工可") && !v.contains("项目名称")) col.putIfAbsent("gk", c);
                else if (v.contains("初设") && !v.contains("项目名称")) col.putIfAbsent("cs", c);
                else if (v.contains("建筑面积") && !v.contains("新增")) col.putIfAbsent("area", c);
            }
            if (!col.containsKey("name")) continue;
            for (int c = 0; c <= row.getLastCellNum(); c++) {
                String v = cellStr(row, c);
                if (v != null && v.trim().matches("序\\s*号")) { col.put("seq", c); break; }
            }
            // fallback：yearcum ç¼ºå¤±æ—¶æŒ‰ startcum+2（总投资/自开始累计/本年计划/自年初累计 çš„标准列序）
            if (!col.containsKey("yearcum") && col.containsKey("startcum")) {
                int yc = col.get("startcum") + 2;
                if (yc <= row.getLastCellNum()) col.put("yearcum", yc);
            }
            // monthdone ç¼ºå¤±æ—¶æŒ‰ yearcum+1
            if (!col.containsKey("monthdone") && col.containsKey("yearcum")) {
                int md = col.get("yearcum") + 1;
                if (md <= row.getLastCellNum()) col.put("monthdone", md);
            }
            for (String k : new String[]{"builder", "nature", "start", "end", "total", "startcum",
                "yearplan", "yearcum", "monthdone", "stage", "desc", "gk", "cs", "area"}) {
                col.putIfAbsent(k, -1);
            }
            col.put("headerRow", r);
            return col;
        }
        return null;
    }

    /** ç»Ÿè®¡ sheet å†…项目数据行数（用于多 sheet åŽ†å²æ–‡ä»¶é€‰å½“月 sheet） */
    private int countInvestRows(Sheet sh, Map<String, Integer> col) {
        int nameCol = col.get("name");
        boolean hasSeq = col.containsKey("seq");
        int seqCol = hasSeq ? col.get("seq") : 0;
        int count = 0;
        for (int r = col.get("headerRow") + 1; r <= sh.getLastRowNum(); r++) {
            Row row = sh.getRow(r);
            if (row == null) continue;
            String name = cellStr(row, nameCol);
            if (name == null || name.trim().isEmpty()) continue;
            String nt = name.trim().replaceAll("[\r\n]+", "");
            if (nt.contains("合计") || nt.contains("总计")) continue;
            if (nt.matches("^[一二三四五六七八九十]+、.*")) continue;
            if (nt.replace(" ", "").matches(".*小\\s*计.*")) continue;
            if (nt.startsWith("填报") || nt.startsWith("单位负责人") || nt.matches("^\\d+、.*")) continue;
            if (!hasSeq) {
                if (nt.length() > 4) count++;
            } else {
                String seq = cellStr(row, seqCol);
                if (seq != null && seq.trim().matches("\\d+(\\.\\d+)?")) count++;
            }
        }
        return count;
    }

    /** ä»Žæ–‡ä»¶åæå–市州（如 "（孝感市道运中心）…" -> å­æ„Ÿå¸‚） */
    private String cityFromFileName(String fileName) {
        for (Map.Entry<String, String> e : INVEST_CITY_SHORT_TO_FULL.entrySet()) {
            if (fileName.contains(e.getKey())) return e.getValue();
        }
        return null;
    }

    /** ä»Ž sheet å¤´éƒ¨ã€Œå¡«æŠ¥å•ä½ï¼šXX」行提取市州 */
    private String cityFromSheetHeader(Sheet sh) {
        for (int r = 0; r < Math.min(6, sh.getLastRowNum() + 1); r++) {
            Row row = sh.getRow(r);
            if (row == null) continue;
            for (int c = 0; c <= row.getLastCellNum(); c++) {
                String v = cellStr(row, c);
                if (v == null || !v.contains("填报单位")) continue;
                java.util.regex.Matcher m = java.util.regex.Pattern
                    .compile("填报单位[：:（(]?(盖章|签章)?[）)]?[：:]*([^\\s，,；;]{2,14})")
                    .matcher(v);
                if (m.find()) {
                    String raw = m.group(2);
                    for (Map.Entry<String, String> e : INVEST_CITY_SHORT_TO_FULL.entrySet()) {
                        if (raw.contains(e.getKey())) return e.getValue();
                    }
                    String city = investmentCity(raw);
                    if (city != null) return city;
                }
            }
        }
        return null;
    }

    /** è§£æžã€Œåäº”五」规划物流项目模板清单，返回规范化项目名集合 */
    private Set<String> loadFiveYearProjectNames() {
        Set<String> names = new LinkedHashSet<>();
        File template = resolveInvestTemplate("模板_十五五规划物流项目进展情况.xls");
        if (template == null || !template.exists()) {
            log.warn("十五五模板不存在，is_five_year æ ‡è®°è·³è¿‡: {}", template);
            return names;
        }
        try (java.io.InputStream is = new java.io.FileInputStream(template);
             Workbook wb = WorkbookFactory.create(is)) {
            Sheet sh = null;
            for (int i = 0; i < wb.getNumberOfSheets(); i++) {
                if (wb.getSheetName(i).contains("分项目投资")) { sh = wb.getSheetAt(i); break; }
            }
            if (sh == null) sh = wb.getSheetAt(0);
            Map<String, Integer> col = findInvestHeader(sh);
            if (col == null) return names;
            int nameCol = col.get("name");
            int seqCol = col.containsKey("seq") ? col.get("seq") : 0;
            for (int r = col.get("headerRow") + 1; r <= sh.getLastRowNum(); r++) {
                Row row = sh.getRow(r);
                if (row == null) continue;
                String seq = cellStr(row, seqCol);
                String name = cellStr(row, nameCol);
                if (seq == null || name == null) continue;
                if (!seq.trim().matches("\\d+")) continue;
                names.add(normalizeProjectName(name.trim()));
            }
        } catch (Exception e) {
            log.error("load five year project names error", e);
        }
        return names;
    }

    /** é¡¹ç›®åè§„范化：去空白/换行/括号内容/标点/「项目」后缀，用于十五五清单匹配 */
    private String normalizeProjectName(String name) {
        String s = name.replaceAll("\\s+", "").replace("\n", "");
        s = s.replaceAll("[（(【\\[][^）)】\\]]*[）)】\\]]", "");
        s = s.replaceAll("[，,。.、；;：:—\\-－_/\\\\|]", "");
        s = s.replace("物流项目", "物流").replace("项目", "");
        return s;
    }

    /** æŠ¥è¡¨æœŸ "2026-07" -> "7月" */
    private String investMonthDir(String period) {
        if (period == null || !period.matches("\\d{4}-\\d{2}")) return "";
        int month = Integer.parseInt(period.substring(5, 7));
        return month + "月";
    }

    /** æŠ•èµ„输入目录定位：user.dir -> user.dir/.. é€çº§å›žé€€ï¼ˆspring-boot:run çš„ user.dir æ˜¯ traffic-audit-server） */
    private File resolveInvestInputDir(String catDir, String monthDir) {
        String rel = "docs/投资/输入/" + catDir + "/" + monthDir;
        for (String baseDir : new String[]{System.getProperty("user.dir"), System.getProperty("user.dir") + "/.."}) {
            File f = new File(baseDir, rel);
            if (f.isDirectory()) return f;
        }
        return null;
    }

    private File resolveInvestTemplate(String fileName) {
        String rel = "docs/投资/模板/" + fileName;
        for (String baseDir : new String[]{System.getProperty("user.dir"), System.getProperty("user.dir") + "/.."}) {
            File f = new File(baseDir, rel);
            if (f.isFile()) return f;
        }
        return null;
    }

    /** åŒç±»åˆ«åŒæŠ¥è¡¨æœŸæœˆåº¦æ•°æ® + INVEST å®¡æ ¸ç»“果清理（幂等） */
    private void cleanInvestMonthly(String category, String period) {
        List<InvestmentProject> sameCat = investProjectMapper.selectList(
            new LambdaQueryWrapper<InvestmentProject>().eq(InvestmentProject::getCategory, category));
        java.util.Set<Long> catProjectIds = new HashSet<>();
        for (InvestmentProject pc : sameCat) catProjectIds.add(pc.getId());
        if (!catProjectIds.isEmpty()) {
            investMonthlyMapper.delete(new LambdaQueryWrapper<InvestmentMonthly>()
                .eq(InvestmentMonthly::getReportPeriod, period)
                .in(InvestmentMonthly::getProjectId, catProjectIds));
        }
        List<Long> investRuleIds = new ArrayList<>();
        for (com.trafficaudit.rulemanage.entity.AuditRule rule : ruleMapper.selectList(null)) {
            if ("INVEST".equals(rule.getReportType())) investRuleIds.add(rule.getId());
        }
        if (!investRuleIds.isEmpty()) {
            auditResultMapper.delete(new LambdaQueryWrapper<AuditResult>()
                .eq(AuditResult::getReportPeriod, period)
                .in(AuditResult::getRuleId, investRuleIds));
        }
    }

    /** é¡¹ç›®ä¸»æ¡£ upsert（按 é¡¹ç›®å+类别）+ æœˆåº¦å†™å…¥ */
    private void saveInvestProjectRow(InvestmentProject project, InvestmentMonthly monthly) {
        InvestmentProject exist = investProjectMapper.selectOne(new LambdaQueryWrapper<InvestmentProject>()
            .eq(InvestmentProject::getProjectName, project.getProjectName())
            .eq(InvestmentProject::getCategory, project.getCategory())
            .last("LIMIT 1"));
        if (exist == null) {
            investProjectMapper.insert(project);
            monthly.setProjectId(project.getId());
        } else {
            project.setId(exist.getId());
            project.setCreatedAt(exist.getCreatedAt());
            investProjectMapper.updateById(project);
            monthly.setProjectId(exist.getId());
        }
        investMonthlyMapper.insert(monthly);
    }

    private String cellStr(Row row, int idx) {
        if (idx < 0) return null;
        return getString(row, idx);
    }

    private Double cellNum(Row row, int idx) {
        if (idx < 0) return 0.0;
        return getDecimal(row, idx);
    }

    private Double cellNumOrNull(Row row, int idx) {
        if (idx < 0) return null;
        return getDecimalOrNull(row, idx);
    }

    /** å¸‚州单表行记录：保留文件 + Excel è¡Œå·ç”¨äºŽå¤±è´¥å®šä½ */
    private static class InvestCityRow {
        final int excelRow;
        final String fileName;
        final InvestmentProject project;
        final InvestmentMonthly monthly;

        InvestCityRow(int excelRow, String fileName, InvestmentProject project, InvestmentMonthly monthly) {
            this.excelRow = excelRow;
            this.fileName = fileName;
            this.project = project;
            this.monthly = monthly;
        }
    }
    /** æŠ•èµ„系统导出导入（审核比对基准），固定8列：行号/单位/时期/计划总投资/自开始累计/本年计划/自年初累计/当月完成 */
    public int importInvestmentSystem(MultipartFile file, String period) throws Exception {
        List<InvestmentSystem> list = new ArrayList<>();
        int failRows = 0;
        try (Workbook wb = WorkbookFactory.create(file.getInputStream())) {
            Sheet sheet = wb.getSheetAt(0);
            for (int r = 1; r <= sheet.getLastRowNum(); r++) {
                Row row = sheet.getRow(r);
                if (row == null) continue;
                String name = getString(row, 1);
                if (name == null || name.trim().isEmpty()) continue;
                InvestmentSystem sys = new InvestmentSystem();
                sys.setReportPeriod(period);
                sys.setProjectName(name.trim());
                sys.setTotalInvestment(getDecimal(row, 3));
                sys.setStartCum(getDecimal(row, 4));
                sys.setYearPlan(getDecimal(row, 5));
                sys.setYearCum(getDecimal(row, 6));
                sys.setMonthDone(getDecimal(row, 7));
                list.add(sys);
            }
        } catch (Exception e) {
            log.error("Investment system parse error", e);
            throw e;
        }
        investSystemMapper.delete(new LambdaQueryWrapper<InvestmentSystem>()
            .eq(InvestmentSystem::getReportPeriod, period));
        int success = 0;
        for (InvestmentSystem sys : list) {
            try {
                investSystemMapper.insert(sys);
                success++;
            } catch (Exception e) {
                failRows++;
                log.error("Investment system insert error: {}", sys.getProjectName(), e);
            }
        }
        recordBatch(file.getOriginalFilename(), "INVEST_SYSTEM", period, list.size(), success, failRows, null);
        log.info("Investment system imported: {} rows for {}", success, period);
        return success;
    }

    /** åŸŽå¸‚公交月报导入（城市公共交通月度运营情况，企业级明细，取公共汽电车字段） */
    public ImportResult importCityBus(MultipartFile file, String period) throws Exception {
        List<CityBusRow> rows = new ArrayList<>();
        try (Workbook wb = WorkbookFactory.create(file.getInputStream())) {
            Sheet sheet = wb.getSheetAt(0);
            Row header = sheet.getRow(0);
            if (header == null || getString(header, 2) == null
                    || !getString(header, 2).contains("企业名称")) {
                throw new RuntimeException("未找到表头行（需包含 ä¼ä¸šåç§° åˆ—）");
            }
            for (int r = 1; r <= sheet.getLastRowNum(); r++) {
                Row row = sheet.getRow(r);
                if (row == null) continue;
                String name = getString(row, 2);
                if (name == null || name.trim().isEmpty()) continue;
                CityBusMonthly item = new CityBusMonthly();
                item.setReportPeriod(period);
                item.setRegionCode(getString(row, 0));
                item.setCity(RegionUtil.cityByCode(getString(row, 0)));
                item.setEnterpriseCode(getString(row, 1));
                item.setEnterpriseName(name.trim());
                item.setOpVehicles(getDecimal(row, 5));
                item.setStopTotal(getDecimal(row, 6));
                item.setStopCity(getDecimal(row, 7));
                item.setPassengerVolume(getDecimal(row, 8));
                item.setPassengerCity(getDecimal(row, 9));
                item.setTurnover(getDecimal(row, 10));
                item.setTurnoverCity(getDecimal(row, 11));
                item.setRailPassengerVolume(getDecimal(row, 13));
                item.setRailTurnover(getDecimal(row, 14));
                item.setFerryPassengerVolume(getDecimal(row, 17));
                item.setFerryTurnover(getDecimal(row, 18));
                item.setAvgDistance(getDecimal(row, 19));
                item.setAvgDistanceCity(getDecimal(row, 20));
                item.setContactPerson(getString(row, 24));
                item.setContactPhone(getString(row, 25));
                item.setReportDate(getDateString(row, 26));
                item.setRateOpVehiclesMom(getDecimal(row, 29));
                item.setRatePassengerMom(getDecimal(row, 30));
                item.setRatePassengerCityMom(getDecimal(row, 31));
                item.setRateChengxiangMom(getDecimal(row, 32));
                item.setRateChengxiangTurnoverMom(getDecimal(row, 33));
                item.setAvgDistanceMomChange(getDecimal(row, 34));
                item.setAvgDistanceCityMomChange(getDecimal(row, 35));
                item.setDailyPassengerPerVehicle(getDecimal(row, 36));
                item.setRateOpVehiclesYoy(getDecimal(row, 39));
                item.setRatePassengerYoy(getDecimal(row, 40));
                item.setRatePassengerCityYoy(getDecimal(row, 41));
                item.setRateChengxiangYoy(getDecimal(row, 42));
                item.setRateChengxiangTurnoverYoy(getDecimal(row, 43));
                item.setStopCityRatio(getDecimal(row, 44));
                item.setPassengerCityRatio(getDecimal(row, 45));
                item.setChengxiangRatio(getDecimal(row, 46));
                item.setRateTurnoverYoy(getDecimal(row, 47));
                item.setRateTurnoverMom(getDecimal(row, 48));
                item.setPassengerChengxiang(getDecimal(row, 49));
                item.setTurnoverChengxiang(getDecimal(row, 50));
                item.setAvgDistanceChengxiang(getDecimal(row, 51));
                item.setVerifyExplanation(getString(row, 65));
                item.setReportNote(getString(row, 66));
                item.setModifyRecord(getString(row, 67));
                rows.add(new CityBusRow(r + 1, item));
            }
        } catch (Exception e) {
            log.error("CityBus import parse error: {}", e.getMessage());
            throw e;
        }
        // å¹‚等：同报表期先清旧数据与 CITY_BUS å®¡æ ¸ç»“æžœ
        cityBusMapper.delete(new LambdaQueryWrapper<CityBusMonthly>()
            .eq(CityBusMonthly::getReportPeriod, period));
        List<Long> busRuleIds = new ArrayList<>();
        for (com.trafficaudit.rulemanage.entity.AuditRule rule : ruleMapper.selectList(null)) {
            if ("CITY_BUS".equals(rule.getReportType())) busRuleIds.add(rule.getId());
        }
        if (!busRuleIds.isEmpty()) {
            auditResultMapper.delete(new LambdaQueryWrapper<AuditResult>()
                .eq(AuditResult::getReportPeriod, period)
                .in(AuditResult::getRuleId, busRuleIds));
        }
        int success = 0;
        List<String> failDetails = new ArrayList<>();
        for (CityBusRow item : rows) {
            try {
                cityBusMapper.insert(item.entity);
                success++;
            } catch (Exception e) {
                Throwable cause = e;
                while (cause.getCause() != null) cause = cause.getCause();
                String reason = cause.getMessage();
                if (reason == null || reason.trim().isEmpty()) reason = e.getMessage();
                failDetails.add("第 " + item.excelRow + " è¡Œï¼ˆ" + item.entity.getEnterpriseName() + "）：" + reason);
                log.error("CityBus insert error: row {}", item.excelRow, e);
            }
        }
        String errorDetail = String.join("\n", failDetails);
        if (errorDetail.length() > 4000) errorDetail = errorDetail.substring(0, 4000) + "\n……";
        recordBatch(file.getOriginalFilename(), "CITY_BUS", period, rows.size(), success, failDetails.size(), errorDetail);
        log.info("CityBus imported: {} rows for {}", success, period);
        return new ImportResult(success, failDetails.size(), failDetails);
    }

    /** åŸŽå¸‚公交行记录：保留 Excel è¡Œå·ç”¨äºŽå¤±è´¥å®šä½ */
    private static class CityBusRow {
        final int excelRow;
        final CityBusMonthly entity;

        CityBusRow(int excelRow, CityBusMonthly entity) {
            this.excelRow = excelRow;
            this.entity = entity;
        }
    }

    /** å·¡æ¸¸å‡ºç§ŸæœˆæŠ¥å¯¼å…¥ï¼ˆå¸‚州级，17 è¡Œï¼›å«æ ¸å®žè¯´æ˜Ž/上报说明/修改记录） */
    public ImportResult importCityTaxi(MultipartFile file, String period) throws Exception {
        List<TaxiRow> rows = new ArrayList<>();
        try (Workbook wb = WorkbookFactory.create(file.getInputStream())) {
            Sheet sheet = wb.getSheetAt(0);
            Row header = sheet.getRow(0);
            if (header == null || getString(header, 2) == null
                    || !getString(header, 2).contains("企业名称")) {
                throw new RuntimeException("未找到表头行（需包含 ä¼ä¸šåç§° åˆ—）");
            }
            for (int r = 1; r <= sheet.getLastRowNum(); r++) {
                Row row = sheet.getRow(r);
                if (row == null) continue;
                String name = getString(row, 2);
                if (name == null || name.trim().isEmpty()) continue;
                CityTaxiMonthly item = new CityTaxiMonthly();
                item.setReportPeriod(period);
                item.setRegionCode(getString(row, 0));
                item.setCity(cityOf(getString(row, 0), name));
                item.setTripTotal(getDecimal(row, 4));
                item.setTripCity(getDecimal(row, 5));
                item.setPassengerVolume(getDecimal(row, 6));
                item.setPassengerCity(getDecimal(row, 7));
                item.setTurnover(getDecimal(row, 8));
                item.setTurnoverCity(getDecimal(row, 9));
                item.setOpVehicles(getDecimal(row, 10));
                item.setAvgDistance(getDecimal(row, 11));
                item.setAvgDistanceCity(getDecimal(row, 12));
                item.setContactPerson(getString(row, 15));
                item.setContactPhone(getString(row, 16));
                item.setReportDate(getDateString(row, 17));
                item.setDailyTripsPerVehicle(getDecimal(row, 18));
                item.setDailyPassengerPerVehicle(getDecimal(row, 19));
                item.setPassengersPerTrip(getDecimal(row, 20));
                item.setRateOpVehiclesMom(getDecimal(row, 21));
                item.setRateOpVehiclesYoy(getDecimal(row, 22));
                item.setRateTripMom(getDecimal(row, 23));
                item.setRateTripYoy(getDecimal(row, 24));
                item.setRatePassengerMom(getDecimal(row, 25));
                item.setRatePassengerYoy(getDecimal(row, 26));
                item.setAvgDistanceMomChange(getDecimal(row, 27));
                item.setPassengersPerTripCity(getDecimal(row, 28));
                item.setRateTripCityMom(getDecimal(row, 29));
                item.setRatePassengerCityMom(getDecimal(row, 30));
                item.setAvgDistanceCityMomChange(getDecimal(row, 31));
                item.setTripCityRatio(getDecimal(row, 32));
                item.setPassengerCityRatio(getDecimal(row, 33));
                item.setPassengersPerTripChengxiang(getDecimal(row, 34));
                item.setRateTripChengxiangMom(getDecimal(row, 35));
                item.setRatePassengerChengxiangMom(getDecimal(row, 36));
                item.setAvgDistanceChengxiang(getDecimal(row, 37));
                item.setVerifyExplanation(getString(row, 38));
                item.setReportNote(getString(row, 39));
                item.setModifyRecord(getString(row, 40));
                rows.add(new TaxiRow(r + 1, item));
            }
        } catch (Exception e) {
            log.error("CityTaxi import parse error: {}", e.getMessage());
            throw e;
        }
        // å¹‚等：同报表期先清旧数据与 CITY_TAXI å®¡æ ¸ç»“æžœ
        cityTaxiMapper.delete(new LambdaQueryWrapper<CityTaxiMonthly>()
            .eq(CityTaxiMonthly::getReportPeriod, period));
        deleteAuditResults(period, "CITY_TAXI");
        int success = 0;
        List<String> failDetails = new ArrayList<>();
        for (TaxiRow item : rows) {
            try {
                cityTaxiMapper.insert(item.entity);
                success++;
            } catch (Exception e) {
                Throwable cause = e;
                while (cause.getCause() != null) cause = cause.getCause();
                String reason = cause.getMessage();
                if (reason == null || reason.trim().isEmpty()) reason = e.getMessage();
                failDetails.add("第 " + item.excelRow + " è¡Œï¼ˆ" + item.entity.getCity() + "）：" + reason);
                log.error("CityTaxi insert error: row {}", item.excelRow, e);
            }
        }
        String errorDetail = String.join("\n", failDetails);
        if (errorDetail.length() > 4000) errorDetail = errorDetail.substring(0, 4000) + "\n……";
        recordBatch(file.getOriginalFilename(), "CITY_TAXI", period, rows.size(), success, failDetails.size(), errorDetail);
        log.info("CityTaxi imported: {} rows for {}", success, period);
        return new ImportResult(success, failDetails.size(), failDetails);
    }

    /** å‡ºç§Ÿè½¦è¿æ”¿è½¦è¾†ä¿¡æ¯å¯¼å…¥ï¼ˆè½¦è¾†çº§æ˜Žç»†ï¼ŒæŒ‰å¸‚州归属统计用） */
    public synchronized int importCityTaxiAuth(MultipartFile file, String period) throws Exception {
        List<CityTaxiAuth> list = new ArrayList<>();
        try (Workbook wb = WorkbookFactory.create(file.getInputStream())) {
            Sheet sheet = wb.getSheetAt(0);
            for (int r = 1; r <= sheet.getLastRowNum(); r++) {
                Row row = sheet.getRow(r);
                if (row == null) continue;
                String plate = getString(row, 0);
                if (plate == null || plate.trim().isEmpty()) continue;
                CityTaxiAuth item = new CityTaxiAuth();
                item.setReportPeriod(period);
                item.setCity(taxiCity(getString(row, 9), getString(row, 8), getString(row, 4), getString(row, 18)));
                item.setPlateNo(plate.trim());
                item.setVehicleType(getString(row, 1));
                item.setBizType(getString(row, 2));
                item.setOwnerName(getString(row, 3));
                item.setLicenseNo(getString(row, 4));
                item.setFuelType(getString(row, 7));
                item.setArchiveNo(getString(row, 8));
                item.setRoadCertNo(getString(row, 9));
                item.setOperatorName(getString(row, 17));
                item.setOperatorAddr(getString(row, 18));
                item.setOpStatus(getString(row, 19));
                item.setCertStatus(getString(row, 20));
                list.add(item);
            }
        } catch (Exception e) {
            log.error("CityTaxiAuth import parse error", e);
            throw e;
        }
        // å¹‚等：同报表期先清旧数据（运政车辆量大，批量清理）
        cityTaxiAuthMapper.delete(new LambdaQueryWrapper<CityTaxiAuth>()
            .eq(CityTaxiAuth::getReportPeriod, period));
        deleteAuditResults(period, "CITY_TAXI");
        // æ‰¹é‡æ’入（BATCH æ¨¡å¼ï¼‰ï¼š42636 è¡Œçº¦ 20~40 ç§’，逐条插入需约 6 åˆ†é’Ÿä¼šè§¦å‘前端超时
        int success = 0;
        int fail = 0;
        try (SqlSession session = sqlSessionFactory.openSession(ExecutorType.BATCH)) {
            CityTaxiAuthMapper batchMapper = session.getMapper(CityTaxiAuthMapper.class);
            for (CityTaxiAuth item : list) {
                batchMapper.insert(item);
            }
            session.flushStatements();
            session.commit();
            success = list.size();
        } catch (Exception e) {
            fail = list.size();
            log.error("CityTaxiAuth batch insert error", e);
        }
        recordBatch(file.getOriginalFilename(), "CITY_TAXI_AUTH", period, list.size(), success, fail, null);
        log.info("CityTaxiAuth imported: {} rows for {}", success, period);
        return success;
    }

    /** è¿æ”¿å‡ºç§Ÿè½¦å¸‚州提取：道路运输证字号→档案号→经营权号→业户地址，取 6 ä½åŒºåˆ’代码 */
    private static final java.util.regex.Pattern TAXI_REGION_PAT =
        java.util.regex.Pattern.compile("(4290\\d{2}|42(?:0[1-9]|1[0-3]|28)\\d{2})");

    private String taxiCity(String... fields) {
        for (String f : fields) {
            if (f == null) continue;
            java.util.regex.Matcher m = TAXI_REGION_PAT.matcher(f);
            if (m.find()) {
                String city = RegionUtil.cityByCode(m.group(1));
                if (city != null) return city;
            }
        }
        return null;
    }

    /** å¸‚州归属：优先按区划代码识别，其次按名称规范化 */
    private String cityOf(String regionCode, String name) {
        String city = RegionUtil.cityByCode(regionCode);
        if (city != null) return city;
        return RegionUtil.normalizeCityName(name);
    }

    /** æ¸…除某报表类型在指定报表期的审核结果（导入幂等） */
    private void deleteAuditResults(String period, String reportType) {
        List<Long> ruleIds = new ArrayList<>();
        for (com.trafficaudit.rulemanage.entity.AuditRule rule : ruleMapper.selectList(null)) {
            if (reportType.equals(rule.getReportType())) ruleIds.add(rule.getId());
        }
        if (!ruleIds.isEmpty()) {
            auditResultMapper.delete(new LambdaQueryWrapper<AuditResult>()
                .eq(AuditResult::getReportPeriod, period)
                .in(AuditResult::getRuleId, ruleIds));
        }
    }

    /** å·¡æ¸¸å‡ºç§Ÿè¡Œè®°å½•ï¼šä¿ç•™ Excel è¡Œå·ç”¨äºŽå¤±è´¥å®šä½ */
    private static class TaxiRow {
        final int excelRow;
        final CityTaxiMonthly entity;

        TaxiRow(int excelRow, CityTaxiMonthly entity) {
            this.excelRow = excelRow;
            this.entity = entity;
        }
    }

    private Sheet pickInvestmentSheet(Workbook wb, boolean passenger) {
        if (passenger) {
            for (int i = 0; i < wb.getNumberOfSheets(); i++) {
                String name = wb.getSheetName(i);
                if (name != null && name.contains("明细")) return wb.getSheetAt(i);
            }
            return wb.getSheetAt(0);
        }
        for (int i = 0; i < wb.getNumberOfSheets(); i++) {
            String name = wb.getSheetName(i);
            if (name != null && name.contains("分项目投资")) return wb.getSheetAt(i);
        }
        return wb.getSheetAt(0);
    }

    /** å¸‚州小节行识别：短名/规范名 -> è§„范名，非市州行返回 null */
    private String investmentCity(String a) {
        if (a == null) return null;
        String full = INVEST_CITY_SHORT_TO_FULL.get(a);
        if (full != null) return full;
        String norm = RegionUtil.normalizeCityName(a);
        if (RegionUtil.CITY_LIST.contains(norm)) return norm;
        return null;
    }

    /** å¼€å·¥/建成时间：数字（2025 æˆ– 202501）或文本统一为 yyyy æˆ– yyyyMM */
    private String investTime(String v) {
        if (v == null || v.trim().isEmpty()) return null;
        String t = v.trim();
        if (t.matches("\\d+\\.0")) t = t.substring(0, t.length() - 2);
        if (t.matches("\\d{4}")) return t;
        if (t.matches("\\d{6}")) return t;
        if (t.matches("\\d{4}-\\d{2}-\\d{2}")) return t;
        return t;
    }

    /** æŠ•èµ„行记录：保留 Excel è¡Œå·ç”¨äºŽå¤±è´¥å®šä½ */
    private static class InvestRow {
        final int excelRow;
        final InvestmentProject project;
        final InvestmentMonthly monthly;

        InvestRow(int excelRow, InvestmentProject project, InvestmentMonthly monthly) {
            this.excelRow = excelRow;
            this.project = project;
            this.monthly = monthly;
        }
    }

    // ========== é€šç”¨æ–‡ä»¶å¤¹æ‰¹é‡å¯¼å…¥ï¼ˆæœåŠ¡ç«¯ç›®å½•æµè§ˆå™¨ï¼‰ ==========

    /**
     * ç›®å½•æµè§ˆå™¨ï¼špath ä¸ºç©ºæ—¶è¿”回项目 docs æ•°æ®ç›®å½•ä¸‹çš„子目录；
     * è¿”回当前目录绝对路径、上级目录、子目录列表及其中直接包含的 Excel æ–‡ä»¶å/数量。
     */
    public Map<String, Object> listDirs(String path) throws Exception {
        File cur;
        if (path == null || path.trim().isEmpty()) {
            File docs = resolveDocsDir();
            if (!docs.isDirectory()) {
                throw new RuntimeException("未找到数据目录 docs（当前运行目录：" + System.getProperty("user.dir") + "）");
            }
            cur = docs;
        } else {
            cur = new File(path);
            if (!cur.isDirectory()) {
                throw new RuntimeException("目录不存在或不是文件夹：" + path);
            }
        }
        Map<String, Object> result = new LinkedHashMap<>();
        result.put("current", cur.getAbsolutePath());
        result.put("parent", cur.getParent() == null ? "" : cur.getParent());
        List<Map<String, Object>> dirs = new ArrayList<>();
        File[] subs = cur.listFiles(File::isDirectory);
        if (subs != null) {
            Arrays.sort(subs, Comparator.comparing(File::getName));
            for (File d : subs) {
                if (d.isHidden()) continue;
                Map<String, Object> m = new LinkedHashMap<>();
                m.put("name", d.getName());
                m.put("path", d.getAbsolutePath());
                dirs.add(m);
            }
        }
        result.put("dirs", dirs);
        List<String> excelFiles = new ArrayList<>();
        File[] files = cur.listFiles((d, n) -> {
            String lower = n.toLowerCase();
            return lower.endsWith(".xlsx") || lower.endsWith(".xls");
        });
        if (files != null) {
            Arrays.sort(files, Comparator.comparing(File::getName));
            for (File f : files) excelFiles.add(f.getName());
        }
        result.put("excelCount", excelFiles.size());
        result.put("files", excelFiles);
        return result;
    }

    /** å‘上查找项目 docs æ•°æ®ç›®å½•ï¼ˆå…¼å®¹ä»Ž IDEA ä»¥ server æ¨¡å—目录启动的情况） */
    private File resolveDocsDir() {
        File base = new File(System.getProperty("user.dir"));
        File cur = base;
        for (int i = 0; i < 4 && cur != null; i++) {
            File candidate = new File(cur, "docs");
            if (candidate.isDirectory()) return candidate;
            cur = cur.getParentFile();
        }
        return new File(base, "docs");
    }

    /**
     * ä»ŽæœåŠ¡ç«¯æ–‡ä»¶å¤¹æ‰¹é‡å¯¼å…¥ï¼šåªæ‰«æ dir ç›´æŽ¥åŒ…含的 .xlsx/.xls，
     * æŒ‰ type é€ä¸ªè°ƒç”¨å¯¹åº”导入方法（与上传导入同一套解析逻辑），返回逐文件结果。
     */
    public Map<String, Object> importFromDir(String type, String period, boolean skipImported, String dir) throws Exception {
        File folder = new File(dir);
        if (!folder.isDirectory()) {
            throw new RuntimeException("目录不存在或不是文件夹：" + dir);
        }
        File[] files = folder.listFiles((d, n) -> {
            String lower = n.toLowerCase();
            return lower.endsWith(".xlsx") || lower.endsWith(".xls");
        });
        if (files == null || files.length == 0) {
            throw new RuntimeException("目录中没有 Excel æ–‡ä»¶ï¼ˆ.xlsx/.xls）：" + folder.getAbsolutePath());
        }
        Arrays.sort(files, Comparator.comparing(File::getName));
        List<Map<String, Object>> fileResults = new ArrayList<>();
        int totalSuccess = 0, totalFail = 0;
        for (File f : files) {
            Map<String, Object> fr = new LinkedHashMap<>();
            fr.put("fileName", f.getName());
            try {
                String filePeriod = detectPeriod(f.getName(), period);
                if (filePeriod == null || filePeriod.trim().isEmpty()) {
                    throw new RuntimeException("无法从文件名识别报表期（支持 2026å¹´7月 / 2026.7 / 2026-07 / 7月），也未选择报表期：" + f.getName());
                }
                fr.put("period", filePeriod);
                if (skipImported && alreadyImported(filePeriod, f.getName())) {
                    fr.put("skipped", true);
                    fr.put("success", 0);
                    fr.put("fail", 0);
                    totalFail++;
                    fileResults.add(fr);
                    continue;
                }
                byte[] bytes;
                try (InputStream is = new FileInputStream(f)) {
                    bytes = IoUtil.readBytes(is);
                }
                MultipartFile mf = new ByteArrayMultipartFile(f.getName(), bytes);
                ImportResult r = importDirFile(type, mf, filePeriod);
                fr.put("success", r.getSuccess());
                fr.put("fail", r.getFail());
                if (r.getFail() > 0 && r.getFailDetails() != null && !r.getFailDetails().isEmpty()) {
                    String d = r.getFailDetails().get(0);
                    if (d.length() > 300) d = d.substring(0, 300);
                    fr.put("error", d);
                }
                totalSuccess += r.getSuccess();
                totalFail += r.getFail();
            } catch (Exception e) {
                String msg = e.getMessage() == null ? e.toString() : e.getMessage();
                if (msg.length() > 300) msg = msg.substring(0, 300);
                fr.put("success", 0);
                fr.put("fail", 0);
                fr.put("error", msg);
                totalFail++;
            }
            fileResults.add(fr);
        }
        Map<String, Object> result = new LinkedHashMap<>();
        result.put("type", type);
        result.put("total", fileResults.size());
        result.put("success", totalSuccess);
        result.put("fail", totalFail);
        result.put("files", fileResults);
        return result;
    }

    /**
     * æŒ‰æ–‡ä»¶è·¯å¾„导入单个 Excel（供前端逐文件导入显示进度）。
     * æŠ¥è¡¨æœŸä¼˜å…ˆä»Žæ–‡ä»¶åè¯†åˆ«ï¼ˆå¦‚ 2026å¹´7月 / 2026.7 / 2026-07 / 7月），识别不到才用 period。
     */
    public Map<String, Object> importDirFileByPath(String type, String period, boolean skipImported, String filePath) throws Exception {
        File f = new File(filePath);
        if (!f.isFile()) {
            throw new RuntimeException("文件不存在：" + filePath);
        }
        String filePeriod = detectPeriod(f.getName(), period);
        if (filePeriod == null || filePeriod.trim().isEmpty()) {
            throw new RuntimeException("无法从文件名识别报表期（支持 2026å¹´7月 / 2026.7 / 2026-07 / 7月），也未选择报表期：" + f.getName());
        }
        Map<String, Object> fr = new LinkedHashMap<>();
        fr.put("fileName", f.getName());
        fr.put("period", filePeriod);
        if (skipImported && alreadyImported(filePeriod, f.getName())) {
            fr.put("skipped", true);
            fr.put("success", 0);
            fr.put("fail", 0);
            fr.put("error", "该报表期已导入过此文件，已跳过（如需覆盖请取消勾选“跳过已导入文件”）");
            return fr;
        }
        byte[] bytes;
        try (InputStream is = new FileInputStream(f)) {
            bytes = IoUtil.readBytes(is);
        }
        ImportResult r = importDirFile(type, new ByteArrayMultipartFile(f.getName(), bytes), filePeriod);
        fr.put("success", r.getSuccess());
        fr.put("fail", r.getFail());
        if (r.getFail() > 0 && r.getFailDetails() != null && !r.getFailDetails().isEmpty()) {
            String d = r.getFailDetails().get(0);
            if (d.length() > 300) d = d.substring(0, 300);
            fr.put("error", d);
        }
        return fr;
    }

    /** è¯¥æŠ¥è¡¨æœŸæ˜¯å¦å·²æˆåŠŸå¯¼å…¥è¿‡åŒåæ–‡ä»¶ï¼ˆç”¨äºŽæ–‡ä»¶å¤¹é‡å¤å¯¼å…¥æ—¶è·³è¿‡ï¼‰ */
    private boolean alreadyImported(String period, String fileName) {
        if (period == null || fileName == null) return false;
        Long cnt = importBatchMapper.selectCount(new LambdaQueryWrapper<ImportBatch>()
            .eq(ImportBatch::getReportPeriod, period)
            .eq(ImportBatch::getFileName, fileName)
            .eq(ImportBatch::getFailRows, 0));
        return cnt != null && cnt > 0;
    }

    /** ä»Žæ–‡ä»¶åè¯†åˆ«æŠ¥è¡¨æœŸï¼š2026å¹´7月 / 2026å¹´07月 / 2026.7 / 2026-07 / 202607 / 7月（无年份用 period å¹´ä»½æˆ–当前年份） */
    private String detectPeriod(String fileName, String defaultPeriod) {
        if (fileName == null) return defaultPeriod;
        String name = fileName.replace("（", "(").replace("）", ")").replace(" ", "");
        java.util.regex.Matcher m;
        m = java.util.regex.Pattern.compile("(\\d{4})\\s*å¹´\\s*(\\d{1,2})\\s*月").matcher(name);
        if (m.find()) return String.format("%04d-%02d", Integer.parseInt(m.group(1)), Integer.parseInt(m.group(2)));
        m = java.util.regex.Pattern.compile("(\\d{4})[.\\-/\\s](\\d{1,2})").matcher(name);
        if (m.find()) return String.format("%04d-%02d", Integer.parseInt(m.group(1)), Integer.parseInt(m.group(2)));
        m = java.util.regex.Pattern.compile("(?:^|[^\\d])(\\d{4})(\\d{2})(?=[^\\d]|$)").matcher(name);
        if (m.find()) {
            int y = Integer.parseInt(m.group(1));
            int mo = Integer.parseInt(m.group(2));
            if (y >= 2000 && y <= 2100 && mo >= 1 && mo <= 12) {
                return String.format("%04d-%02d", y, mo);
            }
        }
        m = java.util.regex.Pattern.compile("(\\d{1,2})\\s*月").matcher(name);
        if (m.find()) {
            int mo = Integer.parseInt(m.group(1));
            if (mo >= 1 && mo <= 12) {
                return String.format("%04d-%02d", defaultYear(defaultPeriod), mo);
            }
        }
        return defaultPeriod;
    }

    private int defaultYear(String defaultPeriod) {
        if (defaultPeriod != null && defaultPeriod.matches("\\d{4}-\\d{2}")) {
            return Integer.parseInt(defaultPeriod.substring(0, 4));
        }
        return java.time.Year.now().getValue();
    }

    /** ç±»åž‹åˆ†å‘：与上传导入同一套解析方法 */
    private ImportResult importDirFile(String type, MultipartFile file, String period) throws Exception {
        switch (type) {
            case "h2032": return importH2032(file, period);
            case "passengerMonthly": return importPassengerMonthly(file, period);
            case "passengerIndividual": return importPassengerIndividual(file, period);
            case "passengerAuth": return importPassengerAuth(file, period);
            case "energyMonthly": return importEnergyMonthly(file, period);
            case "energyAuth": return importEnergyAuth(file, period);
            case "cityBus": return importCityBus(file, period);
            case "cityTaxi": return importCityTaxi(file, period);
            case "cityTaxiAuth": return new ImportResult(importCityTaxiAuth(file, period), 0, new ArrayList<>());
            case "investment": return importInvestment(file, period, "客运站场");
            case "investmentLogistics": return importInvestment(file, period, "物流园区");
            case "investmentSystem": return new ImportResult(importInvestmentSystem(file, period), 0, new ArrayList<>());
            case "transportAuth": return new ImportResult(importTransportAuth(file, period), 0, new ArrayList<>());
            case "trackMileage": return new ImportResult(importTrackMileage(file, period), 0, new ArrayList<>());
            case "freightTurnover": return new ImportResult(importFreightTurnover(file, period), 0, new ArrayList<>());
            case "scaleSplit": return new ImportResult(importScaleSplit(file, period), 0, new ArrayList<>());
            default: throw new RuntimeException("不支持的导入类型：" + type);
        }
    }

    /** æŠŠæœåŠ¡ç«¯æ–‡ä»¶åŒ…装为 MultipartFile，复用各导入方法 */
    public static class ByteArrayMultipartFile implements MultipartFile {
        private final String name;
        private final byte[] content;

        public ByteArrayMultipartFile(String name, byte[] content) {
            this.name = name;
            this.content = content;
        }

        @Override
        public String getName() { return name; }

        @Override
        public String getOriginalFilename() { return name; }

        @Override
        public String getContentType() {
            String lower = name.toLowerCase();
            return lower.endsWith(".xls")
                ? "application/vnd.ms-excel"
                : "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
        }

        @Override
        public boolean isEmpty() { return content == null || content.length == 0; }

        @Override
        public long getSize() { return content == null ? 0 : content.length; }

        @Override
        public byte[] getBytes() { return content; }

        @Override
        public InputStream getInputStream() { return new ByteArrayInputStream(content); }

        @Override
        public void transferTo(File dest) throws IOException {
            try (FileOutputStream out = new FileOutputStream(dest)) {
                out.write(content);
            }
        }
    }
}

 traffic-audit-server/src/main/java/com/trafficaudit/llmintegration/service/DbQueryExecutor.java

@@ -95,6 +95,28 @@
                new String[]{"report_period", "region_name", "freight_m01", "freight_m02", "freight_m03", "freight_m04",
                        "freight_m05", "freight_m06", "freight_m07", "freight_m08", "freight_m09", "freight_m10", "freight_m11",
                        "freight_m12", "turnover_m01", "turnover_m12"});
        register("h2031_enterprise_monthly", "公路旅客月报H203-1表(道路旅客运输月度生产情况)",
                new String[]{"id", "report_period", "region_code", "enterprise_code", "enterprise_name", "vehicle_total",
                        "seat_total", "passenger_total", "turnover_total", "avg_distance_total", "verify_explanation"},
                new String[]{"主键", "报表期", "所属地区代码", "企业代码", "企业名称", "车辆数", "载客位数",
                        "客运量(万人)", "旅客周转量(万人公里)", "平均运距(公里)", "企业核实解释"},
                new String[]{"id", "report_period", "enterprise_name", "vehicle_total", "seat_total",
                        "passenger_total", "turnover_total", "avg_distance_total", "verify_explanation"});
        register("city_bus_monthly", "城市公交月度运营情况(企业级，含轨道/轮渡字段)",
                new String[]{"id", "report_period", "region_code", "city", "enterprise_name", "op_vehicles",
                        "passenger_volume", "turnover", "avg_distance", "passenger_chengxiang", "turnover_chengxiang",
                        "verify_explanation"},
                new String[]{"主键", "报表期", "所属地区代码", "市州", "企业名称", "运营车数", "客运量(万人次)",
                        "旅客周转量(万人公里)", "平均运距(公里)", "城际城乡客运量", "城际城乡周转量", "企业核实解释"},
                new String[]{"id", "report_period", "enterprise_name", "op_vehicles", "passenger_volume",
                        "turnover", "avg_distance", "verify_explanation"});
        register("city_taxi_monthly", "巡游出租汽车运营服务情况月报(市州级)",
                new String[]{"id", "report_period", "region_code", "city", "trip_total", "passenger_volume",
                        "turnover", "op_vehicles", "avg_distance", "verify_explanation"},
                new String[]{"主键", "报表期", "所属地区代码", "市州", "载客车次总数", "客运量(万人次)",
                        "旅客周转量(万人公里)", "运营车辆数", "平均运距(公里)", "企业核实解释"},
                new String[]{"id", "report_period", "city", "trip_total", "passenger_volume",
                        "turnover", "op_vehicles", "avg_distance", "verify_explanation"});
        register("audit_result", "审核结果",
                new String[]{"id", "rule_id", "report_id", "enterprise_code", "report_period", "actual_value",
                        "threshold_value", "deviation", "status", "review_comment", "created_at"},

 traffic-audit-server/src/main/java/com/trafficaudit/llmintegration/service/LLMService.java

@@ -159,6 +159,12 @@
            if (ctx.get("reportId") != null) {
                sb.append("关联上报记录ID: ").append(ctx.get("reportId")).append("\n");
            }
            if (ctx.get("reportType") != null) {
                sb.append("关联业务类型: ").append(ctx.get("reportType")).append("\n");
            }
            if (ctx.get("tableName") != null) {
                sb.append("关联数据表: ").append(ctx.get("tableName")).append("（查询该企业解释对应数据时优先查此表，按 id=").append(ctx.get("reportId")).append(" è¿‡æ»¤ï¼‰\n");
            }
        }
        sb.append("\n你可以调用 query_database å·¥å…·æŸ¥è¯¢æ•°æ®åº“获取真实数据，如企业车辆数、吨位、货运量、周转量、轨迹里程、规上规下拆分、去年同期等。\n\n");
        sb.append("数据库表结构如下（列名一律使用 camelCase，例如 enterpriseName、vehicleTotal、freightTotal、turnoverTotal；filters çš„键同样使用 camelCase）：\n");

 traffic-audit-server/src/main/java/com/trafficaudit/reportexport/controller/ReportExportController.java

@@ -2,6 +2,7 @@

import com.trafficaudit.common.Result;
import com.trafficaudit.reportexport.service.ReportExportService;
import com.trafficaudit.system.service.OperationLogService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
@@ -13,6 +14,7 @@

import javax.annotation.Resource;
import java.net.URLEncoder;
import java.util.List;
import java.nio.charset.StandardCharsets;

@Slf4j
@@ -22,30 +24,254 @@

    @Resource
    private ReportExportService reportService;
    @Resource
    private OperationLogService operationLogService;

    /** ç”Ÿæˆ_货运量分市州明细.xlsx */
    @GetMapping("/export/cityDetail")
    public ResponseEntity<byte[]> exportCityDetail(@RequestParam("period") String period) throws Exception {
        return buildResponse(reportService.exportCityDetail(period), "生成_货运量分市州明细.xlsx");
    public ResponseEntity<byte[]> exportCityDetail(@RequestParam("period") String period,
                                                    @RequestParam(value = "mode", defaultValue = "month") String mode) throws Exception {
        logExport("生成_货运量分市州明细.xlsx", period);
        return buildResponse(reportService.exportCityDetail(period, mode), "生成_货运量分市州明细.xlsx");
    }

    /** ç”Ÿæˆ_货运量排名.xlsx */
    @GetMapping("/export/freightRank")
    public ResponseEntity<byte[]> exportFreightRank(@RequestParam("period") String period) throws Exception {
        return buildResponse(reportService.exportFreightRank(period), "生成_货运量排名.xlsx");
    public ResponseEntity<byte[]> exportFreightRank(@RequestParam("period") String period,
                                                     @RequestParam(value = "mode", defaultValue = "month") String mode) throws Exception {
        logExport("生成_货运量排名.xlsx", period);
        return buildResponse(reportService.exportFreightRank(period, mode), "生成_货运量排名.xlsx");
    }

    /** ç”Ÿæˆ_周转量排名.xlsx */
    @GetMapping("/export/turnoverRank")
    public ResponseEntity<byte[]> exportTurnoverRank(@RequestParam("period") String period) throws Exception {
        return buildResponse(reportService.exportTurnoverRank(period), "生成_周转量排名.xlsx");
    public ResponseEntity<byte[]> exportTurnoverRank(@RequestParam("period") String period,
                                                      @RequestParam(value = "mode", defaultValue = "month") String mode) throws Exception {
        logExport("生成_周转量排名.xlsx", period);
        return buildResponse(reportService.exportTurnoverRank(period, mode), "生成_周转量排名.xlsx");
    }

    /** ç”Ÿæˆ_公路旅客分市州明细.xlsx（month: æŠ¥è¡¨æœŸ yyyy-MM；year: å¹´ä»½ yyyy） */
    @GetMapping("/export/passengerCityDetail")
    public ResponseEntity<byte[]> exportPassengerCityDetail(@RequestParam("period") String period,
                                                            @RequestParam(value = "mode", defaultValue = "month") String mode) throws Exception {
        logExport("生成_公路旅客分市州明细.xlsx", period);
        return buildResponse(reportService.exportPassengerCityDetail(period, mode), "生成_公路旅客分市州明细.xlsx");
    }


    /** ç”Ÿæˆ_公路旅客中口径明细.xlsx */
    @GetMapping("/export/passengerMidDetail")
    public ResponseEntity<byte[]> exportPassengerMidDetail(@RequestParam("period") String period,
                                                           @RequestParam(value = "mode", defaultValue = "month") String mode) throws Exception {
        logExport("生成_公路旅客中口径明细.xlsx", period);
        return buildResponse(reportService.exportPassengerMidDetail(period, mode), "生成_公路旅客中口径明细.xlsx");
    }

    /** ç”Ÿæˆ_公路旅客中口径排名.xlsx */
    @GetMapping("/export/passengerMidRank")
    public ResponseEntity<byte[]> exportPassengerMidRank(@RequestParam("period") String period,
                                                         @RequestParam(value = "mode", defaultValue = "month") String mode) throws Exception {
        logExport("生成_公路旅客中口径排名.xlsx", period);
        return buildResponse(reportService.exportPassengerMidRank(period, mode), "生成_公路旅客中口径排名.xlsx");
    }

    /** ç”Ÿæˆ_公路旅客中口径分析.xlsx */
    @GetMapping("/export/passengerMidAnalysis")
    public ResponseEntity<byte[]> exportPassengerMidAnalysis(@RequestParam("period") String period,
                                                             @RequestParam(value = "mode", defaultValue = "month") String mode) throws Exception {
        logExport("生成_公路旅客中口径分析.xlsx", period);
        return buildResponse(reportService.exportPassengerMidAnalysis(period, mode), "生成_公路旅客中口径分析.xlsx");
    }

    /** ç”Ÿæˆ_能运汇总表.xlsx（H204，全省 + å„市州 sheet） */
    @GetMapping("/export/energySummary")
    public ResponseEntity<byte[]> exportEnergySummary(@RequestParam("period") String period) throws Exception {
        logExport("生成_能运汇总表.xlsx", period);
        return buildResponse(reportService.exportEnergySummary(period), "生成_能运汇总表.xlsx");
    }
    /** ç”Ÿæˆ_城市公交客运量分市州明细.xlsx（城市客运第1步，公交） */
    @GetMapping("/export/cityBusDetail")
    public ResponseEntity<byte[]> exportCityBusDetail(@RequestParam("period") String period,
                                                       @RequestParam(value = "mode", defaultValue = "month") String mode) throws Exception {
        logExport("生成_城市公交客运量分市州明细.xlsx", period);
        return buildResponse(reportService.exportCityBusDetail(period, mode), "生成_城市公交客运量分市州明细.xlsx");
    }

    /** ç”Ÿæˆ_巡游出租客运量分市州明细.xlsx（城市客运第2步，巡游出租） */
    @GetMapping("/export/cityTaxiDetail")
    public ResponseEntity<byte[]> exportCityTaxiDetail(@RequestParam("period") String period,
                                                        @RequestParam(value = "mode", defaultValue = "month") String mode) throws Exception {
        logExport("生成_巡游出租客运量分市州明细.xlsx", period);
        return buildResponse(reportService.exportCityTaxiDetail(period, mode), "生成_巡游出租客运量分市州明细.xlsx");
    }

    /** ç”Ÿæˆ_2026年全省预安排计划进度情况汇总.xlsx（投资模块表1） */
    @GetMapping("/export/investPlan")
    public ResponseEntity<byte[]> exportInvestPlan(@RequestParam("period") String period,
                                                    @RequestParam(value = "mode", defaultValue = "month") String mode) throws Exception {
        logExport("生成_全省预安排计划进度情况汇总.xls", period);
        return buildResponse(reportService.investPlan(period, mode), "生成_全省预安排计划进度情况汇总.xls");
    }

    /** ç”Ÿæˆ_"十五五"规划物流项目进展情况.xlsx（投资模块表2） */
    @GetMapping("/export/investFiveYearLogistics")
    public ResponseEntity<byte[]> exportInvestFiveYearLogistics(@RequestParam("period") String period,
                                                                 @RequestParam(value = "mode", defaultValue = "month") String mode) throws Exception {
        logExport("生成_十五五规划物流项目进展情况.xls", period);
        return buildResponse(reportService.investFiveYearLogistics(period, mode), "生成_十五五规划物流项目进展情况.xls");
    }

    /** ç”Ÿæˆ_湖北省（客货站场）亿元投资项目.xls（投资模块表3，投资总表+规上项目表两sheet） */
    @GetMapping("/export/investBillion")
    public ResponseEntity<byte[]> exportInvestBillion(@RequestParam("period") String period,
                                                       @RequestParam(value = "mode", defaultValue = "month") String mode) throws Exception {
        logExport("生成_湖北省（客货站场）亿元投资项目.xls", period);
        return buildResponse(reportService.investBillion(period, mode), "生成_湖北省（客货站场）亿元投资项目.xls");
    }

    /** ç”Ÿæˆ_（经济强县项目）交通物流基础设施投资统计报表.xlsx（投资模块表4） */
    @GetMapping("/export/investCounty")
    public ResponseEntity<byte[]> exportInvestCounty(@RequestParam("period") String period,
                                                      @RequestParam(value = "mode", defaultValue = "month") String mode) throws Exception {
        logExport("生成_经济强县交通物流基础设施投资统计报表.xls", period);
        return buildResponse(reportService.investCounty(period, mode), "生成_经济强县交通物流基础设施投资统计报表.xls");
    }

    /** ç”Ÿæˆ_轨道轮渡客运量分市州明细.xlsx（城市客运，轨道/轮渡取自公交源文件） */
    @GetMapping("/export/cityRailFerryDetail")
    public ResponseEntity<byte[]> exportCityRailFerryDetail(@RequestParam("period") String period,
                                                             @RequestParam(value = "mode", defaultValue = "month") String mode) throws Exception {
        logExport("生成_轨道轮渡客运量分市州明细.xlsx", period);
        return buildResponse(reportService.exportCityRailFerryDetail(period, mode), "生成_轨道轮渡客运量分市州明细.xlsx");
    }

    /** ç”Ÿæˆ_城市客运客运量分市州累计.xlsx（城市分市州_模板底稿） */
    @GetMapping("/export/cityPassengerCitySum")
    public ResponseEntity<byte[]> exportCityPassengerCitySum(@RequestParam("period") String period,
                                                              @RequestParam(value = "mode", defaultValue = "month") String mode) throws Exception {
        logExport("生成_城市客运客运量分市州累计.xlsx", period);
        return buildResponse(reportService.exportCityPassengerCitySum("导入模板_城市分市州.xlsx", period, mode), "生成_城市客运客运量分市州累计.xlsx");
    }

    /** ç”Ÿæˆ_城市客运各市州明细表.xlsx（城市客运各市州明细表_模板底稿） */
    @GetMapping("/export/cityPassengerDetailSum")
    public ResponseEntity<byte[]> exportCityPassengerDetailSum(@RequestParam("period") String period,
                                                                @RequestParam(value = "mode", defaultValue = "month") String mode) throws Exception {
        logExport("生成_城市客运各市州明细表.xlsx", period);
        return buildResponse(reportService.exportCityPassengerCitySum("导入模板_城市客运各市州明细表.xlsx", period, mode), "生成_城市客运各市州明细表.xlsx");
    }

    /** ç”Ÿæˆ_城市客运汇总.xlsx（城市汇总_模板底稿） */
    @GetMapping("/export/cityPassengerSummary")
    public ResponseEntity<byte[]> exportCityPassengerSummary(@RequestParam("period") String period,
                                                              @RequestParam(value = "mode", defaultValue = "month") String mode) throws Exception {
        logExport("生成_城市客运汇总.xlsx", period);
        return buildResponse(reportService.exportCityPassengerSummary(period, mode), "生成_城市客运汇总.xlsx");
    }

    /** ç”Ÿæˆ_城市客运报表系列.zip（一键打包全部：公交/出租/轨道轮渡明细 + åˆ†å¸‚州累计 + å„市州明细表 + æ±‡æ€»ï¼‰ */
    @GetMapping("/export/cityPassengerSeries")
    public ResponseEntity<byte[]> exportCityPassengerSeries(@RequestParam("period") String period,
                                                             @RequestParam(value = "mode", defaultValue = "month") String mode) throws Exception {
        logExportZip("生成_城市客运报表系列.zip", period);
        String fileName = String.format("生成_城市客运报表系列_%s.zip", period);
        String encoded = URLEncoder.encode(fileName, "UTF-8").replace("+", "%20");
        return ResponseEntity.ok()
            .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename*=UTF-8''" + encoded)
            .contentType(MediaType.parseMediaType("application/zip"))
            .body(reportService.exportCityPassengerSeries(period, mode));
    }

    /** ç”Ÿæˆ_货运报表系列.zip（一键打包：明细+排名） */
    @GetMapping("/export/freightSeries")
    public ResponseEntity<byte[]> exportFreightSeries(@RequestParam("period") String period,
                                                       @RequestParam(value = "mode", defaultValue = "month") String mode) throws Exception {
        logExportZip("生成_货运报表系列.zip", period);
        return zipResponse(reportService.exportFreightSeries(period, mode), String.format("生成_货运报表系列_%s.zip", period));
    }

    /** ç”Ÿæˆ_公路旅客报表系列.zip（一键打包：分市州明细+中口径明细/排名/分析） */
    @GetMapping("/export/passengerSeries")
    public ResponseEntity<byte[]> exportPassengerSeries(@RequestParam("period") String period,
                                                        @RequestParam(value = "mode", defaultValue = "month") String mode) throws Exception {
        logExportZip("生成_公路旅客报表系列.zip", period);
        return zipResponse(reportService.exportPassengerSeries(period, mode), String.format("生成_公路旅客报表系列_%s.zip", period));
    }

    /** ç”Ÿæˆ_投资报表系列.zip（一键打包：预安排/十五五/亿元/经济强县） */
    @GetMapping("/export/investSeries")
    public ResponseEntity<byte[]> exportInvestSeries(@RequestParam("period") String period,
                                                      @RequestParam(value = "mode", defaultValue = "month") String mode) throws Exception {
        logExportZip("生成_投资报表系列.zip", period);
        return zipResponse(reportService.exportInvestSeries(period, mode), String.format("生成_投资报表系列_%s.zip", period));
    }

    /** ç”Ÿæˆ_所选报表.zip：types é€—号分隔（前端"生成选中"多选） */
    @GetMapping("/export/selected")
    public ResponseEntity<byte[]> exportSelected(@RequestParam("period") String period,
                                                 @RequestParam(value = "mode", defaultValue = "month") String mode,
                                                 @RequestParam("types") String types) throws Exception {
        List<String> typeList = new java.util.ArrayList<>();
        for (String t : types.split(",")) {
            String s = t.trim();
            if (!s.isEmpty()) typeList.add(s);
        }
        logExportZip("生成_所选报表.zip", period);
        return zipResponse(reportService.exportSelectedSeries(period, mode, typeList),
                String.format("生成_所选报表_%s.zip", period));
    }

    /** å¯¼å‡ºå‰æ•°æ®å°±ç»ªæ ¡éªŒï¼šè¿”回每张报表依赖的数据行数/缺失提示（types é€—号分隔） */
    @GetMapping("/ready")
    public Result<java.util.Map<String, Object>> exportReady(@RequestParam("period") String period,
                                                              @RequestParam(value = "mode", defaultValue = "month") String mode,
                                                              @RequestParam("types") String types) {
        List<String> typeList = new java.util.ArrayList<>();
        for (String t : types.split(",")) {
            String s = t.trim();
            if (!s.isEmpty()) typeList.add(s);
        }
        return Result.ok(reportService.checkExportReady(period, mode, typeList));
    }

    /** æŠ¥è¡¨æ•°æ®é¢„览（轻量版）：就绪 + æœˆåº¦è¦†ç›– + æ ¸å¿ƒæŒ‡æ ‡æ‘˜è¦ + é—®é¢˜æ¸…单（types é€—号分隔） */
    @GetMapping("/preview")
    public Result<java.util.Map<String, Object>> reportPreview(@RequestParam("period") String period,
                                                                @RequestParam(value = "mode", defaultValue = "month") String mode,
                                                                @RequestParam("types") String types) {
        List<String> typeList = new java.util.ArrayList<>();
        for (String t : types.split(",")) {
            String s = t.trim();
            if (!s.isEmpty()) typeList.add(s);
        }
        return Result.ok(reportService.reportPreview(period, mode, typeList));
    }

    private void logExport(String reportName, String period) {
        operationLogService.record("报表生成", "导出报表", reportName + "（报表期：" + period + "）");
    }

    private void logExportZip(String zipName, String period) {
        operationLogService.record("报表生成", "导出报表系列", zipName + "（报表期：" + period + "）");
    }

    private ResponseEntity<byte[]> zipResponse(byte[] data, String fileName) throws Exception {
        String encoded = URLEncoder.encode(fileName, "UTF-8").replace("+", "%20");
        return ResponseEntity.ok()
            .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename*=UTF-8''" + encoded)
            .contentType(MediaType.parseMediaType("application/zip"))
            .body(data);
    }

    private ResponseEntity<byte[]> buildResponse(byte[] data, String fileName) throws Exception {
        String encoded = URLEncoder.encode(fileName, "UTF-8").replace("+", "%20");
        String type = fileName.toLowerCase().endsWith(".xls")
            ? "application/vnd.ms-excel"
            : "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
        return ResponseEntity.ok()
            .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename*=UTF-8''" + encoded)
            .contentType(MediaType.parseMediaType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"))
            .contentType(MediaType.parseMediaType(type))
            .body(data);
    }
}

 traffic-audit-server/src/main/java/com/trafficaudit/reportexport/service/ReportExportService.java

@@ -1,26 +1,66 @@
package com.trafficaudit.reportexport.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.support.SFunction;
import com.trafficaudit.common.util.RegionUtil;
import com.trafficaudit.dataimport.entity.EnergyVehicleQuarterly;
import com.trafficaudit.dataimport.entity.FreightTurnoverImport;
import com.trafficaudit.dataimport.entity.H2032EnterpriseMonthly;
import com.trafficaudit.dataimport.entity.InvestmentMonthly;
import com.trafficaudit.dataimport.entity.CityBusMonthly;
import com.trafficaudit.dataimport.entity.CityTaxiMonthly;
import com.trafficaudit.dataimport.entity.InvestmentProject;
import com.trafficaudit.dataimport.entity.PassengerEnterpriseMonthly;
import com.trafficaudit.dataimport.entity.PassengerIndividualMonthly;
import com.trafficaudit.dataimport.entity.ScaleSplitTransport;
import com.trafficaudit.auditengine.entity.AuditResult;
import com.trafficaudit.auditengine.entity.AuditRun;
import com.trafficaudit.auditengine.mapper.AuditResultMapper;
import com.trafficaudit.auditengine.mapper.AuditRunMapper;
import com.trafficaudit.rulemanage.entity.AuditRule;
import com.trafficaudit.rulemanage.mapper.AuditRuleMapper;
import com.trafficaudit.dataimport.mapper.EnergyVehicleQuarterlyMapper;
import com.trafficaudit.dataimport.mapper.FreightTurnoverImportMapper;
import com.trafficaudit.dataimport.mapper.H2032EnterpriseMonthlyMapper;
import com.trafficaudit.dataimport.mapper.InvestmentMonthlyMapper;
import com.trafficaudit.dataimport.mapper.CityBusMonthlyMapper;
import com.trafficaudit.dataimport.mapper.CityTaxiMonthlyMapper;
import com.trafficaudit.dataimport.mapper.InvestmentProjectMapper;
import com.trafficaudit.dataimport.mapper.PassengerEnterpriseMonthlyMapper;
import com.trafficaudit.dataimport.mapper.PassengerIndividualMonthlyMapper;
import com.trafficaudit.dataimport.mapper.ScaleSplitTransportMapper;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.FormulaEvaluator;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.util.CellRangeAddress;
import org.openxmlformats.schemas.spreadsheetml.x2006.main.STCellType;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

/**
 * æŠ¥è¡¨ç”ŸæˆæœåŠ¡ï¼š3 ç±»è¾“出报表
@@ -37,12 +77,480 @@
    private ScaleSplitTransportMapper scaleSplitMapper;
    @Resource
    private FreightTurnoverImportMapper freightTurnoverMapper;
    @Resource
    private PassengerEnterpriseMonthlyMapper passengerMapper;
    @Resource
    private PassengerIndividualMonthlyMapper passengerIndividualMapper;
    @Resource
    private EnergyVehicleQuarterlyMapper energyMapper;
    @Resource
    private InvestmentProjectMapper investProjectMapper;
    @Resource
    private InvestmentMonthlyMapper investMonthlyMapper;
    @Resource
    private CityBusMonthlyMapper cityBusMapper;
    @Resource
    private CityTaxiMonthlyMapper cityTaxiMapper;
    @Resource
    private AuditResultMapper auditResultMapper;
    @Resource
    private AuditRunMapper auditRunMapper;
    @Resource
    private AuditRuleMapper auditRuleMapper;
    /** åŸŽå¸‚客运模板目录（application.yml city-passenger.template-dir） */
    @Value("${city-passenger.template-dir:docs/城市客运}")
    private String templateDir;
    /** èƒ½è€—汇总模板目录（application.yml energy.template-dir） */
    @Value("${energy.template-dir:docs/公路旅客+能耗}")
    private String energyTemplateDir;
    /** å…¬è·¯æ—…客输出模板目录（application.yml passenger.template-dir） */
    @Value("${passenger.template-dir:docs/公路旅客+能耗/输出}")
    private String passengerTemplateDir;

    /** è´§è¿æŠ¥è¡¨æ¨¡æ¿ç›®å½•ï¼ˆapplication.yml freight.template-dir） */
    @Value("${freight.template-dir:docs/货运}")
    private String freightTemplateDir;

    /** æŠ•èµ„报表模板目录（application.yml investment.template-dir） */
    @Value("${investment.template-dir:docs/投资/模板}")
    private String investTemplateDir;

    // ==================== å¯¼å‡ºå‰æ•°æ®å°±ç»ªæ ¡éªŒï¼ˆP0：防止导出空表） ====================

    /** è¿”回每张报表依赖的数据行数与缺失提示 */
    public Map<String, Object> checkExportReady(String period, String mode, List<String> types) {
        Map<String, Object> result = new LinkedHashMap<>();
        result.put("period", period);
        result.put("mode", mode);
        List<Map<String, Object>> items = new ArrayList<>();
        for (String t : types) {
            Map<String, Object> it = new LinkedHashMap<>();
            it.put("key", t);
            List<String> notes = new ArrayList<>();
            int rows;
            List<String> auditTypes = new ArrayList<>();
            switch (t) {
                case "cityDetail":
                case "freightRank":
                case "turnoverRank":
                    rows = freightReadyRows(period, mode, notes);
                    auditTypes.add("H2032");
                    break;
                case "passengerCityDetail":
                case "passengerMidDetail":
                case "passengerMidRank":
                case "passengerMidAnalysis":
                    rows = passengerReadyRows(period, mode, notes);
                    auditTypes.add("H2031");
                    break;
                case "cityBusDetail":
                case "cityRailFerryDetail":
                    rows = addReadyCount(() -> cityBusMapper.selectCount(periodQw(period, mode, CityBusMonthly::getReportPeriod)), "城市公交月报", notes);
                    auditTypes.add("CITY_BUS");
                    break;
                case "cityTaxiDetail":
                    rows = addReadyCount(() -> cityTaxiMapper.selectCount(periodQw(period, mode, CityTaxiMonthly::getReportPeriod)), "巡游出租月报", notes);
                    auditTypes.add("CITY_TAXI");
                    break;
                case "cityPassengerCitySum":
                case "cityPassengerDetailSum":
                case "cityPassengerSummary":
                    rows = addReadyCount(() -> cityBusMapper.selectCount(periodQw(period, mode, CityBusMonthly::getReportPeriod)), "城市公交月报", notes)
                         + addReadyCount(() -> cityTaxiMapper.selectCount(periodQw(period, mode, CityTaxiMonthly::getReportPeriod)), "巡游出租月报", notes);
                    auditTypes.add("CITY_BUS");
                    auditTypes.add("CITY_TAXI");
                    break;
                case "investPlan":
                case "investFiveYearLogistics":
                case "investBillion":
                case "investCounty":
                    rows = addReadyCount(() -> investMonthlyMapper.selectCount(periodQw(period, mode, InvestmentMonthly::getReportPeriod)), "投资市州单表/汇总数据", notes);
                    auditTypes.add("INVEST");
                    break;
                case "energySummary":
                    rows = addReadyCount(() -> energyMapper.selectCount(periodQw(period, mode, EnergyVehicleQuarterly::getReportPeriod)), "能耗车辆季度数据", notes);
                    auditTypes.add("H204");
                    break;
                default:
                    rows = 0;
                    notes.add("未知报表类型：" + t);
            }
            int auditRows = 0;
            boolean audited = false;
            for (String at : auditTypes) {
                auditRows += auditRowsOf(period, mode, at);
                audited = audited || auditedMarked(period, mode, at);
            }
            it.put("rows", rows);
            it.put("ready", rows > 0);
            it.put("auditRows", auditRows);
            it.put("audited", audited);
            it.put("note", String.join("；", notes));
            items.add(it);
        }
        result.put("items", items);
        return result;
    }

    // ==================== æŠ¥è¡¨æ•°æ®é¢„览（轻量版）：就绪 + æœˆåº¦è¦†ç›– + æ ¸å¿ƒæ‘˜è¦ + é—®é¢˜æ¸…单 ====================

    /** æŠ¥è¡¨æ•°æ®é¢„览：在导出前展示每张表的就绪状态、月度覆盖、核心指标摘要与问题清单 */
    public Map<String, Object> reportPreview(String period, String mode, List<String> types) {
        Map<String, Object> ready = checkExportReady(period, mode, types);
        @SuppressWarnings("unchecked")
        List<Map<String, Object>> items = (List<Map<String, Object>>) ready.get("items");
        Map<String, Map<String, Object>> byKey = new LinkedHashMap<>();
        for (Map<String, Object> it : items) byKey.put((String) it.get("key"), it);

        String year = period != null && period.length() >= 4 ? period.substring(0, 4) : "";
        String yearPrefix = year + "-";
        int month = monthOf(period, mode);
        int yearNum = 0;
        try { yearNum = Integer.parseInt(year); } catch (Exception ignore) {}

        boolean freight = false, passenger = false, cityBus = false, cityTaxi = false, invest = false, energy = false;
        for (String t : types) {
            if (isFreightType(t)) freight = true;
            else if (isPassengerType(t)) passenger = true;
            else if ("cityTaxiDetail".equals(t) || isCityPassengerType(t)) { cityTaxi = true; cityBus = true; }
            else if (isInvestType(t)) invest = true;
            else if ("energySummary".equals(t)) energy = true;
        }

        // æœˆåº¦è¦†ç›–：该年 1..month ä¸­å“ªäº›æœˆæœ‰æºæ•°æ®
        Set<Integer> freightCover = new TreeSet<>();
        Set<Integer> passengerCover = new TreeSet<>();
        Set<Integer> busCover = new TreeSet<>();
        Set<Integer> taxiCover = new TreeSet<>();
        Set<Integer> investCover = new TreeSet<>();
        if (freight) {
            FreightTurnoverImport ftProv = loadFreightTurnover(period).get("湖北省");
            for (int m = 1; m <= month; m++) {
                if (ftProv != null && freightMonth(ftProv, m) != null) freightCover.add(m);
            }
        }
        if (passenger) {
            passengerCover.addAll(monthsWithData(() -> passengerMapper.selectList(new LambdaQueryWrapper<PassengerEnterpriseMonthly>().likeRight(PassengerEnterpriseMonthly::getReportPeriod, yearPrefix)),
                o -> ((PassengerEnterpriseMonthly) o).getReportPeriod(), month));
            passengerCover.addAll(monthsWithData(() -> passengerIndividualMapper.selectList(new LambdaQueryWrapper<PassengerIndividualMonthly>().likeRight(PassengerIndividualMonthly::getReportPeriod, yearPrefix)),
                o -> ((PassengerIndividualMonthly) o).getReportPeriod(), month));
        }
        if (cityBus) {
            busCover.addAll(monthsWithData(() -> cityBusMapper.selectList(new LambdaQueryWrapper<CityBusMonthly>().likeRight(CityBusMonthly::getReportPeriod, yearPrefix)),
                o -> ((CityBusMonthly) o).getReportPeriod(), month));
        }
        if (cityTaxi) {
            taxiCover.addAll(monthsWithData(() -> cityTaxiMapper.selectList(new LambdaQueryWrapper<CityTaxiMonthly>().likeRight(CityTaxiMonthly::getReportPeriod, yearPrefix)),
                o -> ((CityTaxiMonthly) o).getReportPeriod(), month));
        }
        if (invest) {
            investCover.addAll(monthsWithData(() -> investMonthlyMapper.selectList(new LambdaQueryWrapper<InvestmentMonthly>().likeRight(InvestmentMonthly::getReportPeriod, yearPrefix)),
                o -> ((InvestmentMonthly) o).getReportPeriod(), month));
        }

        for (Map.Entry<String, Map<String, Object>> e : byKey.entrySet()) {
            String t = e.getKey();
            Map<String, Object> it = e.getValue();
            List<Map<String, Object>> summary = new ArrayList<>();
            List<String> problems = new ArrayList<>();
            List<Integer> missing = new ArrayList<>();
            List<Integer> coverage = new ArrayList<>();
            if (Boolean.FALSE.equals(it.get("audited"))) problems.add("该报表期尚未审核通过");
            if (isFreightType(t)) {
                coverage.addAll(freightCover);
                missing = missingMonths(freightCover, month);
                freightPreview(period, month, summary, problems);
            } else if (isPassengerType(t)) {
                coverage.addAll(passengerCover);
                missing = missingMonths(passengerCover, month);
                passengerPreview(yearNum, month, t, summary, problems);
            } else if ("cityTaxiDetail".equals(t)) {
                coverage.addAll(taxiCover);
                missing = missingMonths(taxiCover, month);
                cityPassengerPreview(yearPrefix, month, t, summary, problems);
            } else if (isCityPassengerType(t)) {
                if ("cityBusDetail".equals(t) || "cityRailFerryDetail".equals(t)) {
                    // å…¬äº¤/轨道轮渡明细只依赖公交月报表（轨道/轮渡数据在公交表内）
                    coverage.addAll(busCover);
                    missing = missingMonths(busCover, month);
                } else {
                    Set<Integer> cov = new TreeSet<>();
                    cov.addAll(busCover);
                    cov.addAll(taxiCover);
                    coverage.addAll(cov);
                    missing = missingMonths(cov, month);
                }
                cityPassengerPreview(yearPrefix, month, t, summary, problems);
            } else if (isInvestType(t)) {
                coverage.addAll(investCover);
                // æŠ•èµ„为当月报表（无 1..N ç´¯è®¡å£å¾„），只提示当月缺失
                if (!investCover.contains(month)) missing.add(month);
                investPreview(period, mode, summary, problems);
            } else if ("energySummary".equals(t)) {
                Long ec = energyMapper.selectCount(periodQw(period, mode, EnergyVehicleQuarterly::getReportPeriod));
                if (ec != null && ec > 0) coverage.add(month);
                energyPreview(period, mode, summary, problems);
            }
            if (!missing.isEmpty()) {
                problems.add("缺月数据：" + joinMonths(missing) + "（1~" + month + "月累计需逐月齐全）");
            }
            it.put("monthCoverage", coverage);
            it.put("missingMonths", missing);
            it.put("summary", summary);
            it.put("problems", problems);
        }
        return ready;
    }

    private boolean isFreightType(String t) {
        return "cityDetail".equals(t) || "freightRank".equals(t) || "turnoverRank".equals(t);
    }

    private boolean isPassengerType(String t) {
        return "passengerCityDetail".equals(t) || "passengerMidDetail".equals(t) || "passengerMidRank".equals(t) || "passengerMidAnalysis".equals(t);
    }

    private boolean isCityPassengerType(String t) {
        return "cityBusDetail".equals(t) || "cityRailFerryDetail".equals(t) || "cityPassengerCitySum".equals(t)
            || "cityPassengerDetailSum".equals(t) || "cityPassengerSummary".equals(t);
    }

    private boolean isInvestType(String t) {
        return "investPlan".equals(t) || "investFiveYearLogistics".equals(t) || "investBillion".equals(t) || "investCounty".equals(t);
    }

    private boolean isEnergyType(String t) {
        return "energySummary".equals(t);
    }

    /** æŒ‰ report_period like 'yyyy-' ç»Ÿè®¡ 1..limit æœˆä¸­æœ‰æ•°æ®çš„月份（升序） */
    private Set<Integer> monthsWithData(java.util.function.Supplier<java.util.List<?>> rows, java.util.function.Function<Object, String> periodOf, int limit) {
        Set<Integer> set = new TreeSet<>();
        for (Object o : rows.get()) {
            String rp = periodOf.apply(o);
            if (rp == null) continue;
            String[] parts = rp.split("-");
            if (parts.length < 2) continue;
            try {
                int m = Integer.parseInt(parts[1]);
                if (m >= 1 && m <= limit) set.add(m);
            } catch (Exception ignore) {}
        }
        return set;
    }

    /** 1..limit ä¸­ç¼ºå¤±çš„月份 */
    private List<Integer> missingMonths(Set<Integer> coverage, int limit) {
        List<Integer> missing = new ArrayList<>();
        for (int m = 1; m <= limit; m++) if (!coverage.contains(m)) missing.add(m);
        return missing;
    }

    private String joinMonths(List<Integer> months) {
        StringBuilder sb = new StringBuilder();
        for (int m : months) {
            if (sb.length() > 0) sb.append("、");
            sb.append(m).append("月");
        }
        return sb.toString();
    }

    private void addSum(List<Map<String, Object>> summary, String label, Double value, String unit) {
        Map<String, Object> m = new LinkedHashMap<>();
        m.put("label", label);
        m.put("value", value);
        m.put("unit", unit);
        summary.add(m);
    }

    /** è´§è¿æ‘˜è¦ï¼šå…¨çœç´¯è®¡è´§è¿é‡ï¼ˆåˆè®¡/规上/规下）+ å‘¨è½¬é‡ï¼ˆæ‹†åˆ†è¡¨å…¨çœç´¯è®¡è¡Œï¼‰ */
    private void freightPreview(String period, int month, List<Map<String, Object>> summary, List<String> problems) {
        Map<String, FreightTurnoverImport> ft = loadFreightTurnover(period);
        Map<String, Double> h2032Cum = loadH2032FreightCumulative(period);
        ScaleSplitTransport provCum = getProvinceCumulative(period);
        Double total = freightCum(ft.get("湖北省"), month);
        Double totalWan = total == null ? null : round(total / 10000.0, 4);
        double above = 0.0;
        for (Double v : h2032Cum.values()) if (v != null) above += v;
        double aboveWan = round(above / 10000.0, 4);
        Double belowWan = totalWan == null ? null : round(totalWan - aboveWan, 4);
        addSum(summary, "全省累计货运量（合计）", totalWan, "万吨");
        addSum(summary, "其中：规上", aboveWan, "万吨");
        addSum(summary, "其中：规下", belowWan, "万吨");
        if (provCum != null) {
            addSum(summary, "全省累计周转量（合计）", provCum.getTotalTurnover(), "万吨公里");
            addSum(summary, "其中：规上", provCum.getAboveScaleTurnover(), "万吨公里");
            addSum(summary, "其中：规下", provCum.getBelowScaleTurnover(), "万吨公里");
        } else {
            problems.add("拆分表无全省累计行（周转量/规上规下缺）");
        }
        if (totalWan == null) problems.add("模板_货运量周转量无全省累计，累计货运量为空");
    }

    /** æ—…客摘要：企业+个体（分市州）或中口径企业（中口径 3 è¡¨ï¼‰ */
    private void passengerPreview(int yearNum, int month, String type, List<Map<String, Object>> summary, List<String> problems) {
        Map<Integer, Map<String, PassengerAgg>> data = loadPassengerAggMap();
        Map<Integer, Map<String, double[]>> indi = loadPassengerIndividualMap();
        double entPax = 0.0, entTurn = 0.0, indiPax = 0.0, indiTurn = 0.0;
        boolean anyEnt = false, anyIndi = false;
        for (int m = 1; m <= month; m++) {
            PassengerAgg agg = aggOf(data, yearNum, m, "湖北省");
            if (agg != null) {
                entPax += agg.passengerTotal / 10000.0;
                entTurn += agg.turnoverTotal / 10000.0;
                anyEnt = true;
            }
            Map<String, double[]> mm = indi.get(yearNum * 100 + m);
            if (mm != null) {
                double[] pv = mm.get("湖北省");
                if (pv != null) {
                    indiPax += pv[0];
                    indiTurn += pv[1];
                    anyIndi = true;
                }
            }
        }
        if ("passengerCityDetail".equals(type)) {
            addSum(summary, "企业客运量累计", round(entPax, 4), "万人次");
            addSum(summary, "个体客运量累计", round(indiPax, 4), "万人次");
            addSum(summary, "合计客运量累计", round(entPax + indiPax, 4), "万人次");
            addSum(summary, "合计周转量累计", round(entTurn + indiTurn, 4), "万人公里");
            if (!anyEnt && !anyIndi) problems.add("H203-1 æ—…客月报与个体数据均无");
        } else {
            addSum(summary, "中口径客运量累计", round(entPax, 4), "万人次");
            addSum(summary, "中口径周转量累计", round(entTurn, 4), "万人公里");
            if (!anyEnt) problems.add("H203-1 æ—…客月报无企业数据");
        }
    }

    /** åŸŽå¸‚客运摘要：公交/出租/轨道/轮渡全省累计（指标 0..7） */
    private void cityPassengerPreview(String yearPrefix, int month, String type, List<Map<String, Object>> summary, List<String> problems) {
        double[] prov = loadCityPassengerCumulative(yearPrefix, month).getOrDefault("全省", new double[8]);
        boolean allZero = true;
        for (double v : prov) if (v != 0.0) allZero = false;
        switch (type) {
            case "cityTaxiDetail":
                addSum(summary, "出租客运量累计", round(prov[2], 4), "万人次");
                addSum(summary, "出租周转量累计", round(prov[3], 4), "万人公里");
                break;
            case "cityRailFerryDetail":
                addSum(summary, "轨道客运量累计", round(prov[4], 4), "万人次");
                addSum(summary, "轨道周转量累计", round(prov[5], 4), "万人公里");
                addSum(summary, "轮渡客运量累计", round(prov[6], 4), "万人次");
                addSum(summary, "轮渡周转量累计", round(prov[7], 4), "万人公里");
                break;
            case "cityBusDetail":
                addSum(summary, "公交客运量累计", round(prov[0], 4), "万人次");
                addSum(summary, "公交周转量累计", round(prov[1], 4), "万人公里");
                addSum(summary, "轨道客运量累计", round(prov[4], 4), "万人次");
                addSum(summary, "轨道周转量累计", round(prov[5], 4), "万人公里");
                addSum(summary, "轮渡客运量累计", round(prov[6], 4), "万人次");
                addSum(summary, "轮渡周转量累计", round(prov[7], 4), "万人公里");
                break;
            default:
                addSum(summary, "公交客运量累计", round(prov[0], 4), "万人次");
                addSum(summary, "公交周转量累计", round(prov[1], 4), "万人公里");
                addSum(summary, "出租客运量累计", round(prov[2], 4), "万人次");
                addSum(summary, "出租周转量累计", round(prov[3], 4), "万人公里");
                addSum(summary, "轨道客运量累计", round(prov[4], 4), "万人次");
                addSum(summary, "轨道周转量累计", round(prov[5], 4), "万人公里");
                addSum(summary, "轮渡客运量累计", round(prov[6], 4), "万人次");
                addSum(summary, "轮渡周转量累计", round(prov[7], 4), "万人公里");
        }
        if (allZero) problems.add("全省累计值全为 0（公交/出租月报可能未导入）");
    }

    /** æŠ•èµ„摘要：项目数 + æœ¬æœˆå®Œæˆ/自年初/自开始累计 */
    private void investPreview(String period, String mode, List<Map<String, Object>> summary, List<String> problems) {
        List<InvestmentMonthly> list = investMonthlyMapper.selectList(periodQw(period, mode, InvestmentMonthly::getReportPeriod));
        Set<Long> proj = new HashSet<>();
        double monthDone = 0.0, yearCum = 0.0, startCum = 0.0;
        for (InvestmentMonthly m : list) {
            if (m.getProjectId() != null) proj.add(m.getProjectId());
            monthDone += nz(m.getMonthDone());
            yearCum += nz(m.getYearCum());
            startCum += nz(m.getStartCum());
        }
        addSum(summary, "有月度记录项目数", (double) proj.size(), "个");
        addSum(summary, "本月完成投资合计", round(monthDone, 2), "万元");
        addSum(summary, "自年初累计完成", round(yearCum, 2), "万元");
        addSum(summary, "自开始累计完成", round(startCum, 2), "万元");
        if (list.isEmpty()) problems.add("无投资月度数据");
    }

    /** èƒ½è€—摘要：车辆记录数 + ç‡ƒæ²¹æ¶ˆè€—合计（季度表，按所选季度末月） */
    private void energyPreview(String period, String mode, List<Map<String, Object>> summary, List<String> problems) {
        Long cnt = energyMapper.selectCount(periodQw(period, mode, EnergyVehicleQuarterly::getReportPeriod));
        int rows = cnt == null ? 0 : cnt.intValue();
        double fuel = 0.0;
        if (rows > 0) {
            for (EnergyVehicleQuarterly e : energyMapper.selectList(periodQw(period, mode, EnergyVehicleQuarterly::getReportPeriod))) {
                fuel += nz(e.getFuelConsumption());
            }
        }
        addSum(summary, "车辆记录数", (double) rows, "条");
        addSum(summary, "燃油消耗合计", round(fuel, 2), "—");
        if (rows == 0) problems.add("该季度无能耗车辆数据");
    }

    private int freightReadyRows(String period, String mode, List<String> notes) {
        return addReadyCount(() -> freightTurnoverMapper.selectCount(periodQw(period, mode, FreightTurnoverImport::getReportPeriod)), "模板_货运量周转量", notes)
             + addReadyCount(() -> scaleSplitMapper.selectCount(periodQw(period, mode, ScaleSplitTransport::getReportPeriod)), "规上规下拆分表", notes)
             + addReadyCount(() -> h2032Mapper.selectCount(periodQw(period, mode, H2032EnterpriseMonthly::getReportPeriod)), "H203-2 è´§è¿æœˆæŠ¥", notes);
    }

    private int passengerReadyRows(String period, String mode, List<String> notes) {
        return addReadyCount(() -> passengerMapper.selectCount(periodQw(period, mode, PassengerEnterpriseMonthly::getReportPeriod)), "H203-1 æ—…客月报", notes)
             + addReadyCount(() -> passengerIndividualMapper.selectCount(periodQw(period, mode, PassengerIndividualMonthly::getReportPeriod)), "个体客运量/周转量", notes);
    }

    private <T> LambdaQueryWrapper<T> periodQw(String period, String mode, SFunction<T, ?> periodGetter) {
        LambdaQueryWrapper<T> qw = new LambdaQueryWrapper<>();
        if ("year".equals(mode)) {
            qw.likeRight(periodGetter, period);
        } else {
            qw.eq(periodGetter, period);
        }
        return qw;
    }

    private int addReadyCount(java.util.function.Supplier<Long> counter, String label, List<String> notes) {
        Long cnt = counter.get();
        if (cnt == null || cnt <= 0) notes.add("缺数据：" + label);
        return cnt == null ? 0 : cnt.intValue();
    }

    /** è¯¥æŠ¥è¡¨æœŸè¯¥å®¡æ ¸ç±»åž‹å·²äº§ç”Ÿçš„审核记录数（先审核再出表的前置检查） */
    private int auditRowsOf(String period, String mode, String ruleType) {
        List<AuditRule> rules = auditRuleMapper.selectList(new LambdaQueryWrapper<AuditRule>()
            .eq(AuditRule::getReportType, ruleType)
            .eq(AuditRule::getIsEnabled, 1));
        if (rules.isEmpty()) return 0;
        List<Long> ruleIds = new ArrayList<>();
        for (AuditRule r : rules) ruleIds.add(r.getId());
        LambdaQueryWrapper<AuditResult> qw = new LambdaQueryWrapper<>();
        if ("year".equals(mode)) qw.likeRight(AuditResult::getReportPeriod, period);
        else qw.eq(AuditResult::getReportPeriod, period);
        Long cnt = auditResultMapper.selectCount(qw.in(AuditResult::getRuleId, ruleIds));
        return cnt == null ? 0 : cnt.intValue();
    }

    /** è¯¥æŠ¥è¡¨æœŸè¯¥å®¡æ ¸ç±»åž‹æ˜¯å¦å·²æœ‰ã€Œå®¡æ ¸é€šè¿‡æ ‡è®°ã€ï¼ˆaudit_run è¡¨ï¼›çº¿ä¸‹å®¡æ ¸é€šè¿‡/系统审核执行后写入，导出前不再提示未审核） */
    private boolean auditedMarked(String period, String mode, String ruleType) {
        LambdaQueryWrapper<AuditRun> qw = new LambdaQueryWrapper<AuditRun>()
            .eq(AuditRun::getReportType, ruleType);
        if ("year".equals(mode)) qw.likeRight(AuditRun::getReportPeriod, period);
        else qw.eq(AuditRun::getReportPeriod, period);
        Long cnt = auditRunMapper.selectCount(qw);
        return cnt != null && cnt > 0;
    }

    // ==================== 1. ç”Ÿæˆ_货运量分市州明细.xlsx ====================

    public byte[] exportCityDetail(String period) throws Exception {
        int currentMonth = parseMonth(period);
        String year = period.substring(0, 4);
    public byte[] exportCityDetail(String period, String mode) throws Exception {
        int currentMonth = monthOf(period, mode);
        int fillMonths = currentMonth; // 1..N æœˆï¼ˆN>6 æ—¶æ¨¡æ¿è‡ªåŠ¨å‘右扩列到 12 æœˆï¼‰
        boolean extended = fillMonths > 6;
        Map<String, Map<Integer, ScaleSplitTransport>> monthData = loadMonthData(period);
        Map<Integer, ScaleSplitTransport> provinceMonthMap = loadProvinceMonthMap(period);
        ScaleSplitTransport provinceCum = getProvinceCumulative(period);
@@ -51,29 +559,12 @@
        Map<String, Double> h2032FreightCum = loadH2032FreightCumulative(period);
        Map<String, FreightTurnoverImport> ftMap = loadFreightTurnover(period);

        XSSFWorkbook wb = new XSSFWorkbook();
        Sheet sheet = wb.createSheet("货运量分市州明细");

        Row r1 = sheet.createRow(0);
        r1.createCell(0).setCellValue("报表期：" + year + "å¹´" + currentMonth + "月");
        sheet.createRow(1);
        Row header = sheet.createRow(2);
        header.createCell(0).setCellValue("地区 åç§°");
        header.createCell(1).setCellValue("指标");
        CellStyle dateStyle = wb.createCellStyle();
        dateStyle.setDataFormat(wb.getCreationHelper().createDataFormat().getFormat("yyyy-mm-dd"));
        for (int m = 1; m <= currentMonth; m++) {
            Cell c = header.createCell(2 + (m - 1) * 2);
            c.setCellValue(java.sql.Date.valueOf(year + "-" + pad(m) + "-01"));
            c.setCellStyle(dateStyle);
            header.createCell(3 + (m - 1) * 2).setCellValue(m + "月与去年同比");
        }
        int cumCol = 2 + currentMonth * 2;
        header.createCell(cumCol).setCellValue("累计周转量");
        header.createCell(cumCol + 1).setCellValue("同比");
        sheet.createRow(3);

        int rowIdx = 4;
        // ä»¥ docs/货运/生成_货运量分市州明细.xlsx ä¸ºåº•ç¨¿ï¼šä¿ç•™æ ‡é¢˜/表头/合并/列宽/样式，仅替换数据区
        File template = resolveFreightTemplate("生成_货运量分市州明细.xlsx");
        try (InputStream in = new FileInputStream(template);
             XSSFWorkbook wb = new XSSFWorkbook(in)) {
            Sheet sheet = wb.getSheetAt(0);
            if (extended) extendMonthlyColumns(sheet, 2, Integer.parseInt(period.substring(0, 4)), 4, sheet.getLastRowNum());
        String[][] provinceMetrics = {
            {"货运量         ï¼ˆä¸‡å¨ï¼‰", "freight", "total"},
            {"货物周转量     ï¼ˆä¸‡å¨å…¬é‡Œï¼‰", "turnover", "total"},
@@ -83,18 +574,17 @@
            {"其中规下货物周转量  (万吨公里)", "turnover", "below"}
        };
        FreightTurnoverImport ftProvince = ftMap.get("湖北省");
            int rowIdx = 4; // 0-based：第5行起为 å…¨çœ 6 æŒ‡æ ‡
        for (String[] metric : provinceMetrics) {
            Row row = sheet.createRow(rowIdx++);
            row.createCell(0).setCellValue("全省");
            row.createCell(1).setCellValue(metric[0]);
            for (int m = 1; m <= currentMonth; m++) {
                setNumeric(row, 2 + (m - 1) * 2, getProvinceMonthValue(provinceMonthMap, ftProvince, m, metric[1], metric[2], h2032Freight));
                setNumeric(row, 3 + (m - 1) * 2, getProvinceMonthYoy(provinceMonthMap, ftProvince, m, metric[1], metric[2]));
                Row row = sheet.getRow(rowIdx);
                if (row == null) row = sheet.createRow(rowIdx);
                fillFreightDetailRow(row, fillMonths, extended ? 26 : 14,
                    m -> getProvinceMonthValue(provinceMonthMap, ftProvince, m, metric[1], metric[2], h2032Freight),
                    m -> getProvinceMonthYoy(provinceMonthMap, ftProvince, m, metric[1], metric[2]),
                    getProvinceCumValue(provinceCum, ftProvince, metric[1], metric[2], h2032FreightCum, currentMonth),
                    getProvinceCumYoy(provinceCum, ftProvince, metric[1], metric[2], currentMonth));
                rowIdx++;
            }
            setNumeric(row, cumCol, getProvinceCumValue(provinceCum, ftProvince, metric[1], metric[2], h2032FreightCum, currentMonth));
            setNumeric(row, cumCol + 1, getProvinceCumYoy(provinceCum, ftProvince, metric[1], metric[2], currentMonth));
        }

        for (String city : RegionUtil.cityList()) {
            String[][] metrics = {
                {"规上+规下货运量(万吨)", "freight", "total"},
@@ -107,29 +597,29 @@
            FreightTurnoverImport ftCity = ftMap.get(city);
            ScaleSplitTransport cum = cumMap.get(city);
            for (String[] metric : metrics) {
                Row row = sheet.createRow(rowIdx++);
                row.createCell(0).setCellValue(RegionUtil.shortName(city));
                row.createCell(1).setCellValue(metric[0]);
                for (int m = 1; m <= currentMonth; m++) {
                    setNumeric(row, 2 + (m - 1) * 2, getCityMonthValue(monthData, ftCity, city, m, metric[1], metric[2], h2032Freight));
                    setNumeric(row, 3 + (m - 1) * 2, getCityMonthYoy(monthData, ftCity, city, m, metric[1], metric[2]));
                }
                setNumeric(row, cumCol, getCityCumValue(cum, ftCity, metric[1], metric[2], h2032FreightCum, city, currentMonth));
                setNumeric(row, cumCol + 1, getCityCumYoy(cum, ftCity, metric[1], metric[2], currentMonth));
                    Row row = sheet.getRow(rowIdx);
                    if (row == null) row = sheet.createRow(rowIdx);
                    fillFreightDetailRow(row, fillMonths, extended ? 26 : 14,
                        m -> getCityMonthValue(monthData, ftCity, city, m, metric[1], metric[2], h2032Freight),
                        m -> getCityMonthYoy(monthData, ftCity, city, m, metric[1], metric[2]),
                        getCityCumValue(cum, ftCity, metric[1], metric[2], h2032FreightCum, city, currentMonth),
                        getCityCumYoy(cum, ftCity, metric[1], metric[2], currentMonth));
                    rowIdx++;
            }
        }

        autoWidth(sheet, cumCol + 2);
        return toBytes(wb);
        }
    }
    // ==================== 2. ç”Ÿæˆ_货运量排名.xlsx ====================

    public byte[] exportFreightRank(String period) throws Exception {
    public byte[] exportFreightRank(String period, String mode) throws Exception {
        String year = period.substring(0, 4);
        int month = parseMonth(period);
        int month = monthOf(period, mode);
        Map<String, FreightTurnoverImport> ftMap = loadFreightTurnover(period);
        Map<String, Double> h2032FreightCum = loadH2032FreightCumulative(period);
        Map<String, Double> h2032FreightYoy = computeH2032Yoy(period);
        Map<String, Double> h2032FreightCumLast = loadH2032FreightCumulative(
            (Integer.parseInt(period.substring(0, 4)) - 1) + period.substring(4));

        Map<String, Double> above = new HashMap<>();
        Map<String, Double> below = new HashMap<>();
@@ -146,6 +636,15 @@
        Double provTotal = freightCum(ftMap.get("湖北省"), month);
        Double provBelow = provTotal == null ? null : round(provTotal - provAboveWan, 4);
        Double provTotalYoy = freightCumYoy(ftMap.get("湖北省"), month);
        double provAboveLast = 0.0;
        for (Double v : h2032FreightCumLast.values()) {
            if (v != null) provAboveLast += v;
        }
        Double provAboveYoy = provAboveLast == 0.0 ? null : round((provAbove - provAboveLast) / provAboveLast, 4);
        Double provTotalLast = lastFreightCum(ftMap.get("湖北省"), month);
        Double provBelowLast = provTotalLast == null ? null : round(provTotalLast - provAboveLast / 10000.0, 4);
        Double provBelowYoy = provBelowLast == null || provBelowLast == 0.0 ? null
            : round((provBelow - provBelowLast) / provBelowLast, 4);

        for (String city : RegionUtil.cityList()) {
            Double a = h2032FreightCum.get(city);
@@ -155,81 +654,439 @@
            total.put(city, t);
            below.put(city, t == null ? null : round(t - aWan, 4));
            aboveYoy.put(city, h2032FreightYoy.get(city));
            belowYoy.put(city, null);
            // è§„下同比 = (规下今年 - è§„下去年) / è§„下去年；规下去年 = æ¨¡æ¿åŽ»å¹´åˆè®¡ - H2032去年规上
            Double tLast = lastFreightCum(ftMap.get(city), month);
            Double aLast = h2032FreightCumLast.get(city);
            double aLastWan = aLast == null ? 0.0 : round(aLast / 10000.0, 4);
            Double belowLast = tLast == null ? null : round(tLast - aLastWan, 4);
            Double b = below.get(city);
            belowYoy.put(city, belowLast == null || belowLast == 0.0 || b == null
                ? null : round((b - belowLast) / belowLast, 4));
            totalYoy.put(city, freightCumYoy(ftMap.get(city), month));
        }

        XSSFWorkbook wb = new XSSFWorkbook();
        Sheet sheet = wb.createSheet("货运量排名");

        Row title = sheet.createRow(0);
        title.createCell(0).setCellValue(year + "å¹´1-" + month + "月全省分市州累计完成公路货运量情况");

        int rowIdx = 1;
        rowIdx = writeRankHead(sheet, rowIdx, "货运量", "吨");
        rowIdx = writeFreightRankRows(sheet, rowIdx, null, above, below, total, aboveYoy, belowYoy, totalYoy,
            provAboveWan, provBelow, provTotal, null, null, provTotalYoy, true);
        for (String city : RegionUtil.cityList()) {
            rowIdx = writeFreightRankRows(sheet, rowIdx, city, above, below, total, aboveYoy, belowYoy, totalYoy,
                provAboveWan, provBelow, provTotal, null, null, provTotalYoy, false);
        // ä»¥ docs/货运/生成_货运量排名.xlsx ä¸ºåº•ç¨¿ï¼šä¿ç•™è¡¨å¤´/合并/列宽/样式与 Q/R å æ¯”公式，仅替换数据
        File template = resolveFreightTemplate("生成_货运量排名.xlsx");
        try (InputStream in = new FileInputStream(template);
             XSSFWorkbook wb = new XSSFWorkbook(in)) {
            Sheet sheet = wb.getSheetAt(0);
            sheet.getRow(0).getCell(0).setCellValue(year + "å¹´" + cumRange(month) + "全省分市州累计完成公路货运量情况");
            sheet.getRow(22).getCell(0).setCellValue(year + "å¹´" + month + "月全省分市州累计完成公路货运量情况");
            fillFreightRankBlock(sheet, 3, above, below, total, aboveYoy, belowYoy, totalYoy,
                provAboveWan, provBelow, provTotal, provAboveYoy, provBelowYoy, provTotalYoy);
            fillFreightRankBlock(sheet, 25, above, below, total, aboveYoy, belowYoy, totalYoy,
                provAboveWan, provBelow, provTotal, provAboveYoy, provBelowYoy, provTotalYoy);
            try {
                wb.getCreationHelper().createFormulaEvaluator().evaluateAll();
            } catch (Exception e) {
                log.warn("货运量排名模板公式求值失败: {}", e.getMessage());
        }

        // æœ¬æœˆåŒºå—（当月标题 + ç´¯è®¡æ•°æ®ï¼Œä¸Žæ ·ä¾‹ç»“构一致）
        sheet.createRow(rowIdx++);
        Row title2 = sheet.createRow(rowIdx++);
        title2.createCell(0).setCellValue(year + "å¹´" + month + "月全省分市州累计完成" + "公路货运量情况");
        rowIdx = writeRankHead(sheet, rowIdx, "货运量", "吨");
        rowIdx = writeFreightRankRows(sheet, rowIdx, null, above, below, total, aboveYoy, belowYoy, totalYoy,
            provAboveWan, provBelow, provTotal, null, null, provTotalYoy, true);
        for (String city : RegionUtil.cityList()) {
            rowIdx = writeFreightRankRows(sheet, rowIdx, city, above, below, total, aboveYoy, belowYoy, totalYoy,
                provAboveWan, provBelow, provTotal, null, null, provTotalYoy, false);
        }

        // æœ«å°¾ç©ºè¡Œï¼ˆä¸Žæ ·ä¾‹ç»“构对齐）
        for (int i = 0; i < 4; i++) sheet.createRow(rowIdx++);

        autoWidth(sheet, 18);
        return toBytes(wb);
        }
    }

    // ==================== 3. ç”Ÿæˆ_周转量排名.xlsx ====================

    public byte[] exportTurnoverRank(String period) throws Exception {
    public byte[] exportTurnoverRank(String period, String mode) throws Exception {
        String year = period.substring(0, 4);
        int month = parseMonth(period);
        int month = monthOf(period, mode);
        Map<String, ScaleSplitTransport> cumMap = loadCumulativeMap(period);
        ScaleSplitTransport province = getProvinceCumulative(period);

        XSSFWorkbook wb = new XSSFWorkbook();
        Sheet sheet = wb.createSheet("周转量排名");

        Row title = sheet.createRow(0);
        title.createCell(0).setCellValue(year + "å¹´1-" + month + "月全省分市州累计完成公路货物运输周转量情况");

        int rowIdx = 1;
        rowIdx = writeRankHead(sheet, rowIdx, "周转量", "吨公里");
        rowIdx = writeTurnoverRankRows(sheet, rowIdx, null, cumMap, province, true);
        for (String city : RegionUtil.cityList()) {
            rowIdx = writeTurnoverRankRows(sheet, rowIdx, city, cumMap, province, false);
        }

        // æœ¬æœˆåŒºå—（当月标题 + ç´¯è®¡æ•°æ®ï¼Œä¸Žæ ·ä¾‹ç»“构一致）
        sheet.createRow(rowIdx++);
        Row title2 = sheet.createRow(rowIdx++);
        title2.createCell(0).setCellValue(year + "å¹´" + month + "月全省分市州累计完成" + "公路货物运输周转量情况");
        rowIdx = writeRankHead(sheet, rowIdx, "周转量", "吨公里");
        rowIdx = writeTurnoverRankRows(sheet, rowIdx, null, cumMap, province, true);
        for (String city : RegionUtil.cityList()) {
            rowIdx = writeTurnoverRankRows(sheet, rowIdx, city, cumMap, province, false);
        }

        // æœ«å°¾ç©ºè¡Œï¼ˆä¸Žæ ·ä¾‹ç»“构对齐）
        for (int i = 0; i < 4; i++) sheet.createRow(rowIdx++);

        autoWidth(sheet, 18);
        // ä»¥ docs/货运/生成_周转量排名.xlsx ä¸ºåº•ç¨¿ï¼šä¿ç•™è¡¨å¤´/合并/列宽/样式，仅替换数据；Q/R å æ¯”为模板缓存值，按新数据重算
        File template = resolveFreightTemplate("生成_周转量排名.xlsx");
        try (InputStream in = new FileInputStream(template);
             XSSFWorkbook wb = new XSSFWorkbook(in)) {
            Sheet sheet = wb.getSheetAt(0);
            sheet.getRow(0).getCell(0).setCellValue(year + "å¹´" + cumRange(month) + "全省分市州累计完成公路货物运输周转量情况");
            sheet.getRow(22).getCell(0).setCellValue(year + "å¹´" + month + "月全省分市州累计完成公路货物运输周转量情况");
            fillTurnoverRankBlock(sheet, 3, cumMap, province);
            fillTurnoverRankBlock(sheet, 25, cumMap, province);
        return toBytes(wb);
    }
    }
    /** è´§è¿æŠ¥è¡¨æ¨¡æ¿å®šä½ï¼ˆdocs/货运） */
    private File resolveFreightTemplate(String fileName) throws Exception {
        return resolveAnyTemplate(freightTemplateDir, fileName);
    }

    /** å†™è´§è¿æ¨¡æ¿æ•°æ®å•å…ƒæ ¼ï¼šå…¬å¼åˆ—不动；有值先清空再写（POI å¯¹å…¬å¼å•å…ƒæ ¼åªæ›´æ–°ç¼“存），无值清空模板样例 */
    private void setFreightCell(Row row, int idx, Double v) {
        Cell c = row.getCell(idx);
        if (c != null && c.getCellType() == CellType.FORMULA) return;
        if (c == null) c = row.createCell(idx);
        c.setBlank();
        if (v != null) c.setCellValue(v);
    }

    private void setFreightCell(Row row, int idx, Integer v) {
        if (v == null) {
            setFreightCell(row, idx, (Double) null);
        } else {
            setFreightCell(row, idx, v.doubleValue());
        }
    }

    // ==================== æœˆåº¦æ¨¡æ¿è‡ªåŠ¨æ‰©åˆ—（1-6月 â†’ 1-12月） ====================

    /** æœˆåº¦æ¨¡æ¿å‘右扩列：累计列（14/15）移到末尾（26/27），7..12 æœˆåˆ—ç”± 1 æœˆåˆ—克隆（表头/样式/公式引用同步） */
    private void extendMonthlyColumns(Sheet sheet, int headerRow, int year, int dataStartRow, int dataEndRow) {
        moveColumnPair(sheet, headerRow, 14, 26, dataEndRow); // ç´¯è®¡/累计同比 â†’ AA/AB
        for (int m = 7; m <= 12; m++) {
            int dst = 2 + (m - 1) * 2;
            cloneColumnPair(sheet, headerRow, 2, 3, dst, dst + 1, year, m, dataStartRow, dataEndRow);
        }
        fixCumulativeFormulas(sheet, headerRow, dataEndRow); // AA ç´¯è®¡å…¬å¼ = 12 ä¸ªæœˆå€¼ä¹‹å’Œ
    }

    /** æŠŠä¸€åˆ—对（值列+同比列）从 src ç§»åˆ° dst（含表头/数据/样式/合并/列宽），src å†…容清空 */
    private void moveColumnPair(Sheet sheet, int headerRow, int src, int dst, int lastRow) {
        for (int r = headerRow; r <= lastRow; r++) {
            copyCellForColumn(sheet, r, src, r, dst, false);
            copyCellForColumn(sheet, r, src + 1, r, dst + 1, false);
            clearCellContent(sheet, r, src);
            clearCellContent(sheet, r, src + 1);
        }
        moveMergedRegion(sheet, src, dst);
        moveMergedRegion(sheet, src + 1, dst + 1);
        copyColumnWidth(sheet, src, dst);
        copyColumnWidth(sheet, src + 1, dst + 1);
    }

    /** æŠŠ 1 æœˆåˆ—对克隆为 m æœˆåˆ—对：表头文本/日期修正、样式复制、非跨簿公式克隆并同步列引用 */
    private void cloneColumnPair(Sheet sheet, int headerRow, int srcVal, int srcYoy, int dstVal, int dstYoy,
                                 int year, int month, int dataStartRow, int dataEndRow) {
        for (int r = headerRow; r <= dataEndRow; r++) {
            boolean dataZone = r >= dataStartRow;
            cloneCellForMonth(sheet, r, srcVal, dstVal, year, month, dataZone);
            cloneCellForMonth(sheet, r, srcYoy, dstYoy, year, month, dataZone);
        }
        cloneMergedRegion(sheet, srcVal, dstVal);
        cloneMergedRegion(sheet, srcYoy, dstYoy);
        copyColumnWidth(sheet, srcVal, dstVal);
        copyColumnWidth(sheet, srcYoy, dstYoy);
    }

    /** å¤åˆ¶å•æ ¼ï¼šmove=false åŽŸæ ·å¤åˆ¶ï¼›move=true è¡¨å¤´æ–‡æœ¬/日期修正、数据区仅样式+非跨簿公式（列引用同步） */
    private void copyCellForColumn(Sheet sheet, int r, int srcC, int dstR, int dstC, boolean monthClone) {
        Row srcRow = sheet.getRow(r);
        if (srcRow == null) return;
        Cell src = srcRow.getCell(srcC);
        if (src == null) return;
        Cell dst = getOrCreateCell(sheet, dstR, dstC);
        dst.setBlank();
        dst.setCellStyle(src.getCellStyle());
        if (!monthClone) {
            if (src.getCellType() == CellType.FORMULA) {
                String f = src.getCellFormula();
                if (f != null && !f.contains("#REF!")) dst.setCellFormula(f);
            } else if (src.getCellType() == CellType.STRING) {
                dst.setCellValue(src.getStringCellValue());
            } else if (src.getCellType() == CellType.NUMERIC) {
                dst.setCellValue(src.getNumericCellValue());
            } else if (src.getCellType() == CellType.BOOLEAN) {
                dst.setCellValue(src.getBooleanCellValue());
            }
        }
    }

    /** å…‹éš†å•æ ¼åˆ°ç›®æ ‡æœˆåˆ—：表头行（dataZone=false）修正月份/年份文本或日期；数据区仅样式+非跨簿公式克隆 */
    private void cloneCellForMonth(Sheet sheet, int r, int srcC, int dstC, int year, int month, boolean dataZone) {
        Row srcRow = sheet.getRow(r);
        if (srcRow == null) return;
        Cell src = srcRow.getCell(srcC);
        if (src == null) return;
        Cell dst = getOrCreateCell(sheet, r, dstC);
        dst.setBlank();
        dst.setCellStyle(src.getCellStyle());
        if (!dataZone) {
            if (src.getCellType() == CellType.NUMERIC && org.apache.poi.ss.usermodel.DateUtil.isCellDateFormatted(src)) {
                java.util.Calendar cal = java.util.Calendar.getInstance();
                cal.set(year, month - 1, 1, 0, 0, 0);
                cal.clear(java.util.Calendar.MILLISECOND);
                dst.setCellValue(cal.getTime());
            } else if (src.getCellType() == CellType.STRING) {
                String t = src.getStringCellValue();
                if (t != null && !t.isEmpty()) {
                    dst.setCellValue(t.replaceFirst("^\\d{4}å¹´", year + "å¹´").replaceFirst("(\\d+)月", month + "月"));
                }
            }
            return;
        }
        // æ•°æ®åŒºï¼šä»…复制样式；非跨簿、非 #REF! çš„公式克隆并同步月值列引用
        if (src.getCellType() == CellType.FORMULA) {
            String f = src.getCellFormula();
            if (f != null && !f.contains("[") && !f.contains("#REF!")) {
                dst.setCellFormula(shiftMonthFormula(f, colLetter(dstC)));
            }
        }
    }

    /** å…¬å¼åˆ—引用平移：本表月值列（C/E/G/I/K/M/O/Q/S/U/W/Y）→ ç›®æ ‡åˆ—字母；排除跨簿 [..]! å¼•ç”¨ */
    private String shiftMonthFormula(String formula, String dstColLetter) {
        return formula.replaceAll("(?<![A-Za-z0-9\\[\\]!])([CEGIKMOQSUWY])(\\d+)", dstColLetter + "$2");
    }

    /** AA ç´¯è®¡åˆ—公式重写为 12 ä¸ªæœˆå€¼ä¹‹å’Œï¼ˆæ¨¡æ¿åŽŸä¸º 1-6 æœˆä¹‹å’Œï¼‰ */
    private void fixCumulativeFormulas(Sheet sheet, int headerRow, int dataEndRow) {
        for (int r = headerRow; r <= dataEndRow; r++) {
            Row row = sheet.getRow(r);
            if (row == null) continue;
            Cell c = row.getCell(26);
            if (c == null || c.getCellType() != CellType.FORMULA) continue;
            String f = c.getCellFormula();
            if (f == null) continue;
            java.util.regex.Matcher m = java.util.regex.Pattern
                .compile("(?<![A-Za-z0-9\\[\\]!])([CEGIKMOQSUWY])(\\d+)").matcher(f);
            if (!m.find()) continue;
            int rowNum = Integer.parseInt(m.group(2));
            StringBuilder sb = new StringBuilder();
            for (char col : new char[]{'C', 'E', 'G', 'I', 'K', 'M', 'O', 'Q', 'S', 'U', 'W', 'Y'}) {
                if (sb.length() > 0) sb.append("+");
                sb.append(col).append(rowNum);
            }
            c.setCellFormula(sb.toString());
        }
    }

    /** åˆå¹¶å•å…ƒæ ¼ï¼šsrc å•åˆ—合并 â†’ dst åˆ—（同形状），并移除原合并 */
    private void moveMergedRegion(Sheet sheet, int srcCol, int dstCol) {
        java.util.List<CellRangeAddress> moves = new java.util.ArrayList<>();
        for (CellRangeAddress m : sheet.getMergedRegions()) {
            if (m.getFirstColumn() == srcCol && m.getLastColumn() == srcCol) moves.add(m);
        }
        for (CellRangeAddress m : moves) {
            sheet.addMergedRegion(new CellRangeAddress(m.getFirstRow(), m.getLastRow(), dstCol, dstCol));
            for (int i = sheet.getNumMergedRegions() - 1; i >= 0; i--) {
                if (sheet.getMergedRegion(i).equals(m)) {
                    sheet.removeMergedRegion(i);
                    break;
                }
            }
        }
    }

    /** åˆå¹¶å•å…ƒæ ¼ï¼šsrc å•åˆ—合并 â†’ dst åˆ—（同形状，保留原合并） */
    private void cloneMergedRegion(Sheet sheet, int srcCol, int dstCol) {
        for (CellRangeAddress m : sheet.getMergedRegions()) {
            if (m.getFirstColumn() == srcCol && m.getLastColumn() == srcCol) {
                sheet.addMergedRegion(new CellRangeAddress(m.getFirstRow(), m.getLastRow(), dstCol, dstCol));
            }
        }
    }

    private void copyColumnWidth(Sheet sheet, int src, int dst) {
        try {
            int w = sheet.getColumnWidth(src);
            if (w > 0) sheet.setColumnWidth(dst, w);
        } catch (Exception ignore) { }
    }

    private Cell getOrCreateCell(Sheet sheet, int r, int c) {
        Row row = sheet.getRow(r);
        if (row == null) row = sheet.createRow(r);
        Cell cell = row.getCell(c);
        if (cell == null) cell = row.createCell(c);
        return cell;
    }

    private void clearCellContent(Sheet sheet, int r, int c) {
        Row row = sheet.getRow(r);
        if (row == null) return;
        Cell cell = row.getCell(c);
        if (cell != null) cell.setBlank();
    }

    private String colLetter(int colIdx) {
        return org.apache.poi.ss.util.CellReference.convertNumToColString(colIdx);
    }

    /** æ—…客分市州月值（0=客运量/1=周转量/2=个体客运量/3=个体周转量） */
    private double passengerMonthVal(Map<Integer, Map<String, PassengerAgg>> data, Map<Integer, Map<String, double[]>> indi,
                                     int year, int month, String region, int metricIdx) {
        if (metricIdx <= 1) {
            PassengerAgg agg = aggOf(data, year, month, region);
            Double val = agg == null ? null
                : (metricIdx == 0 ? agg.passengerTotal / 10000.0 : agg.turnoverTotal / 10000.0);
            return val == null ? 0.0 : val;
        }
        return individualVal(indi, year, month, region, metricIdx - 2);
    }

    /** æ—…客累计同比（去年 1..months æœˆç´¯è®¡ï¼‰ï¼šæ— åŽ»å¹´æ•°æ®è¿”回 null */
    private Double passengerCumYoy(Map<Integer, Map<String, PassengerAgg>> data, Map<Integer, Map<String, double[]>> indi,
                                   int year, int months, String region, int metricIdx) {
        double v = 0.0, lv = 0.0;
        for (int m = 1; m <= months; m++) {
            v += passengerMonthVal(data, indi, year, m, region, metricIdx);
            lv += passengerMonthVal(data, indi, year - 1, m, region, metricIdx);
        }
        return lv == 0.0 ? null : (v - lv) / lv;
    }

    /** ä¸­å£å¾„月同比：k=-1 è¡¨ç¤ºæ€»è¡Œï¼ˆç­çº¿+公交之和，出租/网约车无源数据按 0）；无去年数据留空 */
    private void fillMidYoyCell(Cell c, Map<Integer, Map<String, double[][]>> mid, int year, int month,
                                String area, int k, boolean volume) {
        double v = 0.0, lv = 0.0;
        if (k == -1) {
            for (int kk = 1; kk <= 4; kk++) {
                if (kk >= 3) continue;
                v += midClassVal(mid, year, month, area, kk, volume);
                lv += midClassVal(mid, year - 1, month, area, kk, volume);
            }
        } else if (k <= 2) {
            v = midClassVal(mid, year, month, area, k, volume);
            lv = midClassVal(mid, year - 1, month, area, k, volume);
        }
        c.setBlank();
        if (v != 0.0 && lv != 0.0) c.setCellValue(round((v - lv) / lv, 4));
    }

    /** ä¸­å£å¾„累计同比列（1..months æœˆç´¯è®¡ï¼›k=-1 æ€»è¡Œ = ç­çº¿+公交） */
    private void fillMidCumYoyColumn(Sheet sheet, Map<Integer, Map<String, double[][]>> mid, int year,
                                     int months, int colIdx) {
        List<String> areas = midTemplateAreas();
        for (int r0 = 4; r0 <= sheet.getLastRowNum(); r0++) {
            int rr = r0 + 1;
            int blockOffset = -1;
            boolean volume = false;
            if (rr >= 5 && rr <= 94) {
                blockOffset = rr - 5;
                volume = true;
            } else if (rr >= 99 && rr <= 188) {
                blockOffset = rr - 99;
                volume = false;
            }
            if (blockOffset < 0 || blockOffset % 5 == 0) continue;
            int k = blockOffset % 5;
            String area = areas.get(blockOffset / 5);
            double v = 0.0, lv = 0.0;
            for (int m = 1; m <= months; m++) {
                if (k <= 2) {
                    v += midClassVal(mid, year, m, area, k, volume);
                    lv += midClassVal(mid, year - 1, m, area, k, volume);
                }
            }
            Row row = sheet.getRow(r0);
            if (row == null) continue;
            Cell c = row.getCell(colIdx);
            if (c == null) c = row.createCell(colIdx);
            c.setBlank();
            if (v != 0.0 && lv != 0.0) c.setCellValue(round((v - lv) / lv, 4));
        }
    }

    /** è´§è¿åˆ†å¸‚州明细行填充：1..fillMonths æœˆå€¼/同比（最多 12 æœˆï¼Œå…¶ä½™æ¸…空）+ ç´¯è®¡/累计同比（cumCol èµ·ä¸¤åˆ—） */
    private void fillFreightDetailRow(Row row, int fillMonths, int cumCol,
                                      java.util.function.IntFunction<Double> monthValue,
                                      java.util.function.IntFunction<Double> monthYoy,
                                      Double cumValue, Double cumYoy) {
        for (int m = 1; m <= (fillMonths > 6 ? 12 : 6); m++) {
            if (m <= fillMonths) {
                setFreightCell(row, 2 + (m - 1) * 2, monthValue.apply(m));
                setFreightCell(row, 3 + (m - 1) * 2, monthYoy.apply(m));
            } else {
                setFreightCell(row, 2 + (m - 1) * 2, (Double) null);
                setFreightCell(row, 3 + (m - 1) * 2, (Double) null);
            }
        }
        setFreightCell(row, cumCol, cumValue);
        setFreightCell(row, cumCol + 1, cumYoy);
    }

    /** è´§è¿é‡æŽ’名块填充：模板 1-based r4 èµ·ï¼ˆå…¨çœ+17市州），Q/R å æ¯”公式保留不动 */
    private void fillFreightRankBlock(Sheet sheet, int start,
                                      Map<String, Double> above, Map<String, Double> below, Map<String, Double> total,
                                      Map<String, Double> aboveYoy, Map<String, Double> belowYoy, Map<String, Double> totalYoy,
                                      Double provAbove, Double provBelow, Double provTotal,
                                      Double provAboveYoy, Double provBelowYoy, Double provTotalYoy) {
        Row provRow = sheet.getRow(start);
        if (provRow == null) provRow = sheet.createRow(start);
        setFreightCell(provRow, 1, provAbove);
        setFreightCell(provRow, 4, provAboveYoy);
        setFreightCell(provRow, 6, provBelow);
        setFreightCell(provRow, 9, provBelowYoy);
        setFreightCell(provRow, 11, provTotal);
        setFreightCell(provRow, 14, provTotalYoy);
        int rowIdx = start + 1;
        for (String city : RegionUtil.cityList()) {
            Row row = sheet.getRow(rowIdx);
            if (row == null) row = sheet.createRow(rowIdx);
            setFreightCell(row, 1, above.get(city));
            setFreightCell(row, 2, rankOfMap(above, city));
            setFreightCell(row, 3, ratioOf(above.get(city), provAbove));
            setFreightCell(row, 4, aboveYoy.get(city));
            setFreightCell(row, 5, yoyRankOfMap(aboveYoy, city));
            setFreightCell(row, 6, below.get(city));
            setFreightCell(row, 7, rankOfMap(below, city));
            setFreightCell(row, 8, ratioOf(below.get(city), provBelow));
            setFreightCell(row, 9, belowYoy.get(city));
            setFreightCell(row, 10, yoyRankOfMap(belowYoy, city));
            setFreightCell(row, 11, total.get(city));
            setFreightCell(row, 12, rankOfMap(total, city));
            setFreightCell(row, 13, ratioOf(total.get(city), provTotal));
            setFreightCell(row, 14, totalYoy.get(city));
            setFreightCell(row, 15, yoyRankOfMap(totalYoy, city));
            rowIdx++;
        }
    }

    /** å‘¨è½¬é‡æŽ’名块填充：模板 1-based r4 èµ·ï¼ˆå…¨çœ+17市州） */
    private void fillTurnoverRankBlock(Sheet sheet, int start,
                                       Map<String, ScaleSplitTransport> cumMap, ScaleSplitTransport province) {
        if (province == null) province = new ScaleSplitTransport();
        Double provAbove = province.getAboveScaleTurnover();
        Double provBelow = province.getBelowScaleTurnover();
        Double provTotal = province.getTotalTurnover();
        Row provRow = sheet.getRow(start);
        if (provRow == null) provRow = sheet.createRow(start);
        setFreightCell(provRow, 1, provAbove);
        setFreightCell(provRow, 4, province.getAboveScaleYoy());
        setFreightCell(provRow, 6, provBelow);
        setFreightCell(provRow, 9, province.getBelowScaleYoy());
        setFreightCell(provRow, 11, provTotal);
        setFreightCell(provRow, 14, province.getTotalYoy());
        setFreightShare(provRow, provAbove, provTotal);
        int rowIdx = start + 1;
        for (String city : RegionUtil.cityList()) {
            Row row = sheet.getRow(rowIdx);
            if (row == null) row = sheet.createRow(rowIdx);
            ScaleSplitTransport cum = cumMap.get(city);
            Double above = cum == null ? null : cum.getAboveScaleTurnover();
            Double below = cum == null ? null : cum.getBelowScaleTurnover();
            Double total = cum == null ? null : cum.getTotalTurnover();
            setFreightCell(row, 1, above);
            setFreightCell(row, 2, cum == null ? null : rankOfTurnover(cumMap, city, 0));
            setFreightCell(row, 3, ratioOf(above, provAbove));
            setFreightCell(row, 4, cum == null ? null : cum.getAboveScaleYoy());
            setFreightCell(row, 5, cum == null ? null : yoyRankOfTurnover(cumMap, city, 0));
            setFreightCell(row, 6, below);
            setFreightCell(row, 7, cum == null ? null : rankOfTurnover(cumMap, city, 1));
            setFreightCell(row, 8, ratioOf(below, provBelow));
            setFreightCell(row, 9, cum == null ? null : cum.getBelowScaleYoy());
            setFreightCell(row, 10, cum == null ? null : yoyRankOfTurnover(cumMap, city, 1));
            setFreightCell(row, 11, total);
            setFreightCell(row, 12, cum == null ? null : rankOfTurnover(cumMap, city, 2));
            setFreightCell(row, 13, ratioOf(total, provTotal));
            setFreightCell(row, 14, cum == null ? null : cum.getTotalYoy());
            setFreightCell(row, 15, cum == null ? null : yoyRankOfTurnover(cumMap, city, 2));
            setFreightShare(row, above, total);
            rowIdx++;
        }
    }

    /** å‘¨è½¬é‡æŽ’名 Q/R å æ¯”：模板为缓存值，按新数据重算（规上占比 1 ä½å°æ•°ï¼‰ */
    private void setFreightShare(Row row, Double above, Double total) {
        if (total != null && total > 0 && above != null) {
            double share = round(above * 10.0 / total, 1);
            setFreightCell(row, 16, share);
            setFreightCell(row, 17, round(10.0 - share, 1));
        } else {
            setFreightCell(row, 16, (Double) null);
            setFreightCell(row, 17, (Double) null);
        }
    }

    // ==================== æ•°æ®åŠ è½½ ====================

    /** å½“月数据: city -> month -> record（不含全省） */
@@ -771,10 +1628,846 @@
        return rank;
    }

    // ==================== 4. ç”Ÿæˆ_公路旅客分市州明细.xlsx（月报/年报） ====================

    /**
     * å…¬è·¯æ—…客分市州明细
     * @param period æœˆæŠ¥: 2026-06（今年1-6月）；年报: 2026（全年12个月）
     * @param mode   month/year
     */
    /**
     * ç”Ÿæˆ_公路旅客分市州.xlsx：以 docs/公路旅客+能耗/输出 æ¨¡æ¿ä¸ºåº•ç¨¿ï¼Œ
     * ä¿ç•™è¡¨å¤´/合并/列宽/公式/样式，仅替换 2026 å¹´ 1..6 æœˆæœˆåº¦åˆ—数据（客运量/周转量/个体行）。
     * 2025/2024 åŽ†å²åˆ—保留模板值；累计/同比/全省行公式保留并重算。
     */
    public byte[] exportPassengerCityDetail(String period, String mode) throws Exception {
        int maxMonth = monthOf(period, mode);
        int currentYear = Integer.parseInt(period.substring(0, 4));
        File template = resolvePassengerTemplate("生成_公路旅客分市州.xlsx");
        try (InputStream in = new FileInputStream(template);
             XSSFWorkbook wb = new XSSFWorkbook(in)) {
            Sheet sheet = wb.getSheetAt(0);
            fixPassengerHeaderYear(sheet, currentYear); // è¡¨å¤´å¹´ä»½åŠ¨æ€åŒ–（不写死 2026）
            Map<Integer, Map<String, PassengerAgg>> data = loadPassengerAggMap();
            Map<Integer, Map<String, double[]>> indi = loadPassengerIndividualMap();
            int fillMonths = maxMonth; // 1..N æœˆï¼ˆN>6 æ—¶æ¨¡æ¿è‡ªåŠ¨å‘右扩列到 12 æœˆï¼‰
            boolean extended = fillMonths > 6;
            if (extended) extendMonthlyColumns(sheet, 1, currentYear, 3, sheet.getLastRowNum());
            String currentRegion = null;
            for (int r = 3; r <= sheet.getLastRowNum(); r++) { // ä»Ž R4 èµ·ï¼šA åˆ—合并行是区域标记（R4 å…¨çœã€R8 æ­¦æ±‰å¸‚…）
                Row row = sheet.getRow(r);
                if (row == null) continue;
                Cell nameCell = row.getCell(0);
                Cell metricCell = row.getCell(1);
                if (metricCell == null) continue;
                String areaName = cellText(nameCell);
                if (areaName != null && !areaName.trim().isEmpty()) {
                    currentRegion = "全省".equals(areaName.trim()) ? "湖北省" : RegionUtil.normalizeCityName(areaName.trim());
                }
                if (currentRegion == null) continue;
                String metric = cellText(metricCell);
                if (metric == null) continue;
                int metricIdx = cityMetricIndexOf(metric);
                if (metricIdx < 0) continue;
                String region = currentRegion;
                for (int m = 1; m <= fillMonths; m++) {
                    int col = 2 + (m - 1) * 2; // C,E,G,I,K,M,O,Q,S,U,W,Y（7-12 æœˆä¸ºæ‰©åˆ—列）
                    Cell c = row.getCell(col);
                    boolean keepFormula = c != null && c.getCellType() == CellType.FORMULA; // å…¨çœ/累计等公式保留
                    double v = passengerMonthVal(data, indi, currentYear, m, region, metricIdx);
                    if (!keepFormula) {
                        if (c == null) c = row.createCell(col);
                        if (v == 0.0) c.setBlank(); else c.setCellValue(round(v, 4));
                    }
                    // åŒæ¯”列：库内去年同月同比（模板 #REF! å…¬å¼æ›¿æ¢ä¸ºæ•°å€¼ï¼Œå…¬å¼è¡Œä¹Ÿè¦†å†™ï¼‰
                    double lv = passengerMonthVal(data, indi, currentYear - 1, m, region, metricIdx);
                    Cell yc = row.getCell(col + 1);
                    if (yc == null) yc = row.createCell(col + 1);
                    if (v == 0.0 || lv == 0.0) yc.setBlank(); else yc.setCellValue(round((v - lv) / lv, 4));
                }
                // ç´¯è®¡åŒæ¯”列（模板 #REF! â†’ åº“内去年 1..N æœˆç´¯è®¡åŒæ¯”数值）
                int cumCol = extended ? 26 : 14;
                Double cumYoy = passengerCumYoy(data, indi, currentYear, fillMonths, region, metricIdx);
                Cell yc2 = row.getCell(cumCol + 1);
                if (yc2 == null) yc2 = row.createCell(cumCol + 1);
                if (cumYoy == null) yc2.setBlank(); else yc2.setCellValue(round(cumYoy, 4));
            }
            recalc(wb);
            return toBytes(wb);
        }
    }

    /** åˆ†å¸‚州表指标行：0=客运量 1=周转量 2=个体客运量 3=个体周转量；无法识别返回 -1 */
    private int cityMetricIndexOf(String metric) {
        if (metric == null) return -1;
        boolean indi = metric.contains("个体");
        if (metric.contains("客运量")) return indi ? 2 : 0;
        if (metric.contains("周转量")) return indi ? 3 : 1;
        return -1;
    }

    private String cellText(Cell c) {
        if (c == null) return null;
        if (c.getCellType() == CellType.STRING) return c.getStringCellValue();
        if (c.getCellType() == CellType.NUMERIC) return String.valueOf(c.getNumericCellValue());
        return null;
    }

    /** ä¸ªä½“客运量/周转量（万人/万人公里） */
    private double individualVal(Map<Integer, Map<String, double[]>> indi, int year, int month, String region, int idx) {
        Map<String, double[]> mm = indi.get(year * 100 + month);
        if (mm == null) return 0;
        double[] arr = mm.get(region);
        if (arr == null) return 0;
        return idx < arr.length ? arr[idx] : 0;
    }

    /** ä¸ªä½“客运量/周转量数据：年*100+月 -> (市州/全省 -> [个体客运量(万人), ä¸ªä½“周转量(万人公里)]) */
    private Map<Integer, Map<String, double[]>> loadPassengerIndividualMap() {
        Map<Integer, Map<String, double[]>> data = new HashMap<>();
        for (PassengerIndividualMonthly e : passengerIndividualMapper.selectList(null)) {
            if (e.getReportPeriod() == null) continue;
            String[] parts = e.getReportPeriod().split("-");
            if (parts.length != 2) continue;
            int y, m;
            try {
                y = Integer.parseInt(parts[0]);
                m = Integer.parseInt(parts[1]);
            } catch (NumberFormatException ex) {
                continue;
            }
            String city = RegionUtil.cityByCode(e.getRegionCode());
            if (city == null) continue;
            int key = y * 100 + m;
            double pass = nz(e.getPassengerCount()) / 10000.0;
            double turn = nz(e.getTurnover()) / 10000.0;
            double[] arr = data.computeIfAbsent(key, k -> new HashMap<>()).computeIfAbsent(city, k -> new double[2]);
            arr[0] += pass;
            arr[1] += turn;
            double[] prov = data.get(key).computeIfAbsent("湖北省", k -> new double[2]);
            prov[0] += pass;
            prov[1] += turn;
        }
        return data;
    }

    private PassengerAgg aggOf(Map<Integer, Map<String, PassengerAgg>> data, int year, int month, String region) {
        Map<String, PassengerAgg> monthMap = data.get(year * 100 + month);
        return monthMap == null ? null : monthMap.get(region);
    }

    private Double cumOf(Map<Integer, Map<String, PassengerAgg>> data, int year, String region, int monthCount, int metricIdx) {
        double sum = 0.0;
        boolean has = false;
        for (int m = 1; m <= monthCount; m++) {
            Double v = metricValue(aggOf(data, year, m, region), metricIdx);
            if (v != null) {
                sum += v;
                has = true;
            }
        }
        return has ? sum : null;
    }

    private Double yoy(Double cur, Double base) {
        if (cur == null || base == null || base == 0.0) return null;
        return round((cur - base) / base, 4);
    }

    /** æŒ‡æ ‡å–值（已换算为万人/万人公里/公里；无数据返回 null） */
    private Double metricValue(PassengerAgg agg, int metric) {
        if (agg == null) return null;
        switch (metric) {
            case 0: return agg.passengerTotal / 10000.0;
            case 1: return agg.passengerTotal / 10000.0;
            case 2: return agg.passengerClass1 / 10000.0;
            case 3: return agg.passengerClass2 / 10000.0;
            case 4: return agg.passengerClass3 / 10000.0;
            case 5: return agg.passengerClass4 / 10000.0;
            case 6: return agg.passengerCharter / 10000.0;
            case 7:
            case 8:
            case 9: return null; // åŸŽå¸‚客运模块数据，暂留空
            case 10: return agg.turnoverTotal / 10000.0;
            case 11: return agg.turnoverClass1 / 10000.0;
            case 12: return agg.turnoverClass2 / 10000.0;
            case 13: return agg.turnoverClass3 / 10000.0;
            case 14: return agg.turnoverClass4 / 10000.0;
            case 15: return agg.turnoverCharter / 10000.0;
            case 16: return ratioOrNull(agg.turnoverTotal, agg.passengerTotal);
            case 17: return ratioOrNull(agg.turnoverClass1, agg.passengerClass1);
            case 18: return ratioOrNull(agg.turnoverClass2, agg.passengerClass2);
            case 19: return ratioOrNull(agg.turnoverClass3, agg.passengerClass3);
            case 20: return ratioOrNull(agg.turnoverClass4, agg.passengerClass4);
            case 21: return ratioOrNull(agg.turnoverCharter, agg.passengerCharter);
            default: return null;
        }
    }

    private Double ratioOrNull(double numerator, double denominator) {
        if (denominator == 0.0) return null;
        return numerator / denominator;
    }

    /** å•æœˆå…¨å¸‚州企业汇总 */
    private static class PassengerAgg {
        double passengerTotal;
        double passengerClass1;
        double passengerClass2;
        double passengerClass3;
        double passengerClass4;
        double passengerCharter;
        double turnoverTotal;
        double turnoverClass1;
        double turnoverClass2;
        double turnoverClass3;
        double turnoverClass4;
        double turnoverCharter;

        void add(PassengerEnterpriseMonthly e) {
            passengerTotal += nz(e.getPassengerClass1()) + nz(e.getPassengerClass2()) + nz(e.getPassengerClass3())
                + nz(e.getPassengerClass4()) + nz(e.getPassengerCharter());
            passengerClass1 += nz(e.getPassengerClass1());
            passengerClass2 += nz(e.getPassengerClass2());
            passengerClass3 += nz(e.getPassengerClass3());
            passengerClass4 += nz(e.getPassengerClass4());
            passengerCharter += nz(e.getPassengerCharter());
            turnoverTotal += nz(e.getTurnoverClass1()) + nz(e.getTurnoverClass2()) + nz(e.getTurnoverClass3())
                + nz(e.getTurnoverClass4()) + nz(e.getTurnoverCharter());
            turnoverClass1 += nz(e.getTurnoverClass1());
            turnoverClass2 += nz(e.getTurnoverClass2());
            turnoverClass3 += nz(e.getTurnoverClass3());
            turnoverClass4 += nz(e.getTurnoverClass4());
            turnoverCharter += nz(e.getTurnoverCharter());
        }

        private double nz(Double v) {
            return v == null ? 0.0 : v;
        }
    }



    // ==================== ä¸­å£å¾„明细/排名/分析（H203-1 å…¬è·¯æ—…客） ====================

    /** åŠ è½½ å¹´*100+月 -> (市州/全省 -> ä¼ä¸šæ±‡æ€») æ•°æ® */
    private Map<Integer, Map<String, PassengerAgg>> loadPassengerAggMap() {
        Map<Integer, Map<String, PassengerAgg>> data = new HashMap<>();
        List<PassengerEnterpriseMonthly> list = passengerMapper.selectList(null);
        for (PassengerEnterpriseMonthly e : list) {
            if (e.getReportPeriod() == null) continue;
            String[] parts = e.getReportPeriod().split("-");
            if (parts.length != 2) continue;
            int y;
            int m;
            try {
                y = Integer.parseInt(parts[0]);
                m = Integer.parseInt(parts[1]);
            } catch (NumberFormatException ex) {
                continue;
            }
            String city = RegionUtil.cityByCode(e.getRegionCode());
            if (city == null) continue;
            int key = y * 100 + m;
            Map<String, PassengerAgg> monthMap = data.computeIfAbsent(key, k -> new HashMap<>());
            monthMap.computeIfAbsent(city, k -> new PassengerAgg()).add(e);
            monthMap.computeIfAbsent("湖北省", k -> new PassengerAgg()).add(e);
        }
        return data;
    }

    /**
     * ä¸­å£å¾„明细：客运量块 + æ—…客周转量块（总/公路班线/城际城乡公交/巡游出租/网约车）
     */
    /**
     * ç”Ÿæˆ_中口径明细.xlsx：以样例为底稿。数据区外部引用公式（班线/公交/出租/网约车）替换为库内数值，
     * 2025 å¹´åˆ—保留模板缓存值（去年数据），内部公式（累计/同比/求和）保留并重算。
     */
    public byte[] exportPassengerMidDetail(String period, String mode) throws Exception {
        int maxMonth = monthOf(period, mode);
        int currentYear = Integer.parseInt(period.substring(0, 4));
        File template = resolvePassengerTemplate("生成_中口径明细.xlsx");
        try (InputStream in = new FileInputStream(template);
             XSSFWorkbook wb = new XSSFWorkbook(in)) {
            Sheet sheet = wb.getSheetAt(0);
            fixPassengerHeaderYear(sheet, currentYear); // è¡¨å¤´å¹´ä»½åŠ¨æ€åŒ–（不写死 2026）
            Map<Integer, Map<String, double[][]>> mid = loadMidClassMap();
            int fillMonths = maxMonth; // 1..N æœˆï¼ˆN>6 æ—¶æ¨¡æ¿è‡ªåŠ¨å‘右扩列到 12 æœˆï¼‰
            boolean extended = fillMonths > 6;
            if (extended) extendMonthlyColumns(sheet, 2, currentYear, 4, sheet.getLastRowNum());
            List<String> areas = midTemplateAreas();
            for (Row row : sheet) {
                if (row == null) continue;
                for (Cell c : row) {
                    if (c.getCellType() != CellType.FORMULA) continue;
                    String f = c.getCellFormula();
                    if (f == null) continue;
                    boolean crossBook = f.contains("[");
                    if (!crossBook && !isYoyMonthCol(c.getColumnIndex() + 1)) continue; // å†…部公式（合计/累计）保留重算；同比列 #REF! è¦†å†™ä¸ºæ•°å€¼
                    if (crossBook && !is2026MonthCol(c.getColumnIndex() + 1)) {
                        keepCached(c); // 2025 å¹´åˆ—保留模板缓存值
                        continue;
                    }
                    int r = c.getRowIndex() + 1;
                    int col = c.getColumnIndex() + 1;
                    int blockOffset = -1;
                    boolean volume = false;
                    if (r >= 5 && r <= 94) {
                        blockOffset = r - 5;
                        volume = true;
                    } else if (r >= 99 && r <= 188) {
                        blockOffset = r - 99;
                        volume = false;
                    }
                    if (blockOffset < 0) {
                        keepCached(c); // r1/r2 å¤‡æ³¨ç­‰
                        continue;
                    }
                    if (blockOffset % 5 == 0) {
                        if (isYoyMonthCol(col)) {
                            fillMidYoyCell(c, mid, currentYear, monthOfCol(col), areas.get(blockOffset / 5), -1, volume);
                        } else {
                            keepCached(c); // æ€»è¡Œå†…部公式（防御）
                        }
                        continue;
                    }
                    int k = blockOffset % 5; // 1=班线 2=公交 3=出租 4=网约车
                    String area = areas.get(blockOffset / 5);
                    if (is2026MonthCol(col)) {
                        fillMidCell(c, mid, currentYear, monthOfCol(col), area, k, volume);
                    } else if (isYoyMonthCol(col)) {
                        fillMidYoyCell(c, mid, currentYear, monthOfCol(col), area, k, volume);
                    } else {
                        keepCached(c); // 2025 å¹´åˆ—保留模板缓存值
                    }
                }
            }
            // ç´¯è®¡åŒæ¯”列（模板 #REF! â†’ åº“内去年 1..N æœˆç´¯è®¡åŒæ¯”数值）
            fillMidCumYoyColumn(sheet, mid, currentYear, fillMonths, extended ? 27 : 15);
            recalc(wb);
            return toBytes(wb);
        }
    }

    /** ä¸­å£å¾„明细模板地区顺序（与 RegionUtil.CITY_LIST ä¸€è‡´ï¼šæ­¦æ±‰å¸‚…神农架林区） */
    private List<String> midTemplateAreas() {
        List<String> areas = new java.util.ArrayList<>();
        areas.add("湖北省");
        areas.addAll(RegionUtil.CITY_LIST);
        return areas;
    }

    private boolean is2026MonthCol(int col) {
        return col >= 3 && col <= 25 && col % 2 == 1;
    }

    /** æœˆåŒæ¯”列（1-based å¶æ•°åˆ— 4..26） */
    private boolean isYoyMonthCol(int col) {
        return col >= 4 && col <= 26 && col % 2 == 0;
    }

    private int monthOfCol(int col) {
        return (col - 1) / 2;
    }

    /** å¡«ä¸­å£å¾„数据单元格：出租/网约车(3/4)显式 0，班线/公交填库内值（无值清空） */
    private void fillMidCell(Cell c, Map<Integer, Map<String, double[][]>> mid, int year, int month, String area, int k, boolean volume) {
        if (k == 3 || k == 4) {
            writeExplicitZero(c); // å‡ºç§Ÿ/网约车暂无数据源，显式 0
            return;
        }
        double v = midClassVal(mid, year, month, area, k, volume);
        // POI setCellValue(double) å¯¹å…¬å¼å•å…ƒæ ¼åªæ›´æ–°ç¼“存不移除公式，必须先 setBlank å†å†™å€¼
        c.setBlank();
        if (v != 0.0) c.setCellValue(round(v, 4));
    }

    /** æ˜¾å¼å†™å…¥ 0（POI setCellValue(0.0) ä¼šè½¬ blank，需操作底层 XML） */
    private void writeExplicitZero(Cell c) {
        c.setBlank();
        if (c instanceof XSSFCell) {
            try {
                ((XSSFCell) c).getCTCell().setT(STCellType.N);
                ((XSSFCell) c).getCTCell().setV("0");
            } catch (Exception e) {
                log.warn("writeExplicitZero failed: {}", e.getMessage());
            }
        }
    }

    private double midClassVal(Map<Integer, Map<String, double[][]>> mid, int year, int month, String area, int k, boolean volume) {
        Map<String, double[][]> mm = mid.get(year * 100 + month);
        if (mm == null) return 0;
        double[][] arr = mm.get(area);
        if (arr == null) return 0;
        if (k < 0 || k >= arr.length) return 0;
        return volume ? arr[k][0] : arr[k][1];
    }

    /** å…¬å¼å•å…ƒæ ¼æ›¿æ¢ä¸ºç¼“存数值（避免跨簿引用断链；非数值缓存置空） */
    private void keepCached(Cell c) {
        try {
            double v = 0.0;
            boolean has = false;
            if (c.getCachedFormulaResultType() == CellType.NUMERIC) {
                v = c.getNumericCellValue();
                has = true;
            }
            c.setBlank();
            if (has && v != 0.0) c.setCellValue(v);
        } catch (Exception e) {
            try { c.setBlank(); } catch (Exception ignore) { }
        }
    }

    /**
     * ä¸­å£å¾„分类月度数据：年*100+月 -> (市州/全省 -> double[5][2])
     * ç»´åº¦ 0=总量 1=公路班线(h2031) 2=城际城乡公交(cityBus) 3=巡游出租 4=网约车；[客运量(万人), å‘¨è½¬é‡(万人公里)]
     */
    private Map<Integer, Map<String, double[][]>> loadMidClassMap() {
        Map<Integer, Map<String, double[][]>> mid = new HashMap<>();
        for (PassengerEnterpriseMonthly e : passengerMapper.selectList(null)) {
            if (e.getReportPeriod() == null) continue;
            String[] parts = e.getReportPeriod().split("-");
            if (parts.length != 2) continue;
            int y, m;
            try {
                y = Integer.parseInt(parts[0]);
                m = Integer.parseInt(parts[1]);
            } catch (NumberFormatException ex) {
                continue;
            }
            String city = RegionUtil.cityByCode(e.getRegionCode());
            if (city == null) continue;
            int key = y * 100 + m;
            double pass = (nz(e.getPassengerClass1()) + nz(e.getPassengerClass2()) + nz(e.getPassengerClass3())
                + nz(e.getPassengerClass4()) + nz(e.getPassengerCharter())) / 10000.0;
            double turn = (nz(e.getTurnoverClass1()) + nz(e.getTurnoverClass2()) + nz(e.getTurnoverClass3())
                + nz(e.getTurnoverClass4()) + nz(e.getTurnoverCharter())) / 10000.0;
            addMidClass(mid, key, city, 1, pass, turn);
            addMidClass(mid, key, "湖北省", 1, pass, turn);
        }
        for (CityBusMonthly b : cityBusMapper.selectList(null)) {
            if (b.getReportPeriod() == null || b.getCity() == null) continue;
            String[] parts = b.getReportPeriod().split("-");
            if (parts.length != 2) continue;
            int y, m;
            try {
                y = Integer.parseInt(parts[0]);
                m = Integer.parseInt(parts[1]);
            } catch (NumberFormatException ex) {
                continue;
            }
            String city = RegionUtil.normalizeCityName(b.getCity());
            if (city == null) continue;
            int key = y * 100 + m;
            addMidClass(mid, key, city, 2, nz(b.getPassengerChengxiang()), nz(b.getTurnoverChengxiang()));
            addMidClass(mid, key, "湖北省", 2, nz(b.getPassengerChengxiang()), nz(b.getTurnoverChengxiang()));
        }
        return mid;
    }

    /** å†™å…¥åˆ†ç±»å€¼å¹¶ç´¯åŠ æ€»é‡ï¼ˆç»´åº¦0） */
    private void addMidClass(Map<Integer, Map<String, double[][]>> mid, int key, String city, int k, double pass, double turn) {
        double[][] arr = mid.computeIfAbsent(key, kk -> new HashMap<>()).computeIfAbsent(city, kk -> new double[5][2]);
        arr[k][0] += pass;
        arr[k][1] += turn;
        arr[0][0] += pass;
        arr[0][1] += turn;
    }

    private int writeMidBlock(Sheet sheet, Map<Integer, Map<String, PassengerAgg>> data, int[] years,
                              int currentYear, int maxMonth, int startRow, String title, boolean volume) {
        Row titleRow = sheet.createRow(startRow);
        titleRow.createCell(0).setCellValue(title);
        Row noteRow = sheet.createRow(startRow + 1);
        noteRow.createCell(0).setCellValue("注：中口径由公路班线、城际城乡公交、城际城乡出租、城际城乡网约车四部分构成");
        Row header = sheet.createRow(startRow + 2);
        header.createCell(0).setCellValue("地区 åç§°");
        header.createCell(1).setCellValue("指标");
        int col = 2;
        for (int y : years) {
            int monthCount = (y == currentYear) ? maxMonth : 12;
            for (int m = 1; m <= monthCount; m++) {
                header.createCell(col++).setCellValue(y + "å¹´" + m + "月");
                header.createCell(col++).setCellValue(m + "月与去年同比");
            }
            header.createCell(col++).setCellValue(y + "年累计");
            header.createCell(col++).setCellValue("累计与去年同比");
        }
        sheet.createRow(startRow + 3);

        String[] metrics = volume ? new String[]{
            "总客运量（万人次）",
            "其中：公路班线客运量（万人次）",
            "城际城乡公交客运量（万人次）",
            "城际城乡巡游出租客运量（万人次）",
            "城际城乡网约车客运量（万人次）"
        } : new String[]{
            "总旅客周转量（万人公里）",
            "其中：公路班线旅客周转量（万人公里）",
            "城际城乡公交旅客周转量（万人公里）",
            "城际城乡巡游出租旅客周转量（万人公里）",
            "城际城乡网约车旅客周转量（万人公里）"
        };

        int rowIdx = startRow + 4;
        List<String> regions = new java.util.ArrayList<>();
        regions.add("湖北省");
        regions.addAll(RegionUtil.cityList());
        for (String region : regions) {
            String label = "湖北省".equals(region) ? "全省" : RegionUtil.shortName(region);
            for (int i = 0; i < metrics.length; i++) {
                Row row = sheet.createRow(rowIdx++);
                row.createCell(0).setCellValue(label);
                row.createCell(1).setCellValue(metrics[i]);
                col = 2;
                for (int y : years) {
                    int monthCount = (y == currentYear) ? maxMonth : 12;
                    for (int m = 1; m <= monthCount; m++) {
                        Double cur = midMetricValue(aggOf(data, y, m, region), i, volume);
                        setNumeric(row, col++, cur == null ? null : round(cur, 4));
                        Double base = midMetricValue(aggOf(data, y - 1, m, region), i, volume);
                        setNumeric(row, col++, yoy(cur, base));
                    }
                    Double cum = midCumOf(data, y, region, monthCount, i, volume);
                    setNumeric(row, col++, cum == null ? null : round(cum, 4));
                    Double cumBase = midCumOf(data, y - 1, region, monthCount, i, volume);
                    setNumeric(row, col++, yoy(cum, cumBase));
                }
            }
        }
        return rowIdx;
    }

    /** ä¸­å£å¾„指标取值：0=总量 1=公路班线 2-4=公交/出租/网约车（城市客运模块未接入，暂空） */
    private Double midMetricValue(PassengerAgg agg, int metric, boolean volume) {
        if (agg == null) return null;
        if (volume) {
            switch (metric) {
                case 0: return agg.passengerTotal / 10000.0;
                case 1: return agg.passengerTotal / 10000.0;
                default: return null;
            }
        }
        switch (metric) {
            case 0: return agg.turnoverTotal / 10000.0;
            case 1: return agg.turnoverTotal / 10000.0;
            default: return null;
        }
    }

    private Double midCumOf(Map<Integer, Map<String, PassengerAgg>> data, int year, String region,
                            int monthCount, int metricIdx, boolean volume) {
        double sum = 0.0;
        boolean has = false;
        for (int m = 1; m <= monthCount; m++) {
            Double v = midMetricValue(aggOf(data, year, m, region), metricIdx, volume);
            if (v != null) {
                sum += v;
                has = true;
            }
        }
        return has ? sum : null;
    }

    /**
     * ä¸­å£å¾„排名：左块=当月（客运量/周转量及排名/同比/增速排名），右块=1-N月累计（同结构）
     */
    /**
     * ç”Ÿæˆ_中口径排名.xlsx：单块累计（选 1 ä¸ªæœˆ=当月，选 1-6 æœˆ=累计），RANK/SUM å…¬å¼ä¿ç•™ã€‚
     */
    public byte[] exportPassengerMidRank(String period, String mode) throws Exception {
        int maxMonth = monthOf(period, mode);
        int currentYear = Integer.parseInt(period.substring(0, 4));
        File template = resolvePassengerTemplate("生成_中口径排名.xlsx");
        try (InputStream in = new FileInputStream(template);
             XSSFWorkbook wb = new XSSFWorkbook(in)) {
            Sheet sheet = wb.getSheetAt(0);
            Map<Integer, Map<String, double[][]>> mid = loadMidClassMap();
            Row title = sheet.getRow(0);
            if (title != null && title.getCell(0) != null) {
                if (maxMonth == 12) {
                    title.getCell(0).setCellValue(currentYear + "å¹´1-12月全省分市州累计完成道路客运生产情况");
                } else if (maxMonth == 1) {
                    title.getCell(0).setCellValue(currentYear + "å¹´1月全省分市州完成道路客运生产情况");
                } else {
                    title.getCell(0).setCellValue(currentYear + "å¹´1-" + maxMonth + "月全省分市州累计完成道路客运生产情况");
                }
            }
            // å…¨çœè¡Œ r3：B3/F3 ä¸º SUM å…¬å¼ä¿ç•™ï¼›D3/H3 åŒæ¯”填值（0-based åˆ— 3/7）
            setValOrBlank(sheet, 2, 3, yoyOf(midCumClass(mid, currentYear, "湖北省", maxMonth, 0, true),
                midCumClass(mid, currentYear - 1, "湖北省", maxMonth, 0, true)));
            setValOrBlank(sheet, 2, 7, yoyOf(midCumClass(mid, currentYear, "湖北省", maxMonth, 0, false),
                midCumClass(mid, currentYear - 1, "湖北省", maxMonth, 0, false)));
            // å¸‚å·žè¡Œ r4-20：B/F ç´¯è®¡å€¼ã€D/H åŒæ¯”ï¼›C/E/G/I æŽ’名公式保留
            List<String> cities = RegionUtil.CITY_LIST;
            for (int i = 0; i < cities.size(); i++) {
                String city = cities.get(i);
                int r0 = 3 + i;
                double pass = midCumClass(mid, currentYear, city, maxMonth, 0, true);
                double turn = midCumClass(mid, currentYear, city, maxMonth, 0, false);
                double lastPass = midCumClass(mid, currentYear - 1, city, maxMonth, 0, true);
                double lastTurn = midCumClass(mid, currentYear - 1, city, maxMonth, 0, false);
                setValOrBlank(sheet, r0, 1, pass == 0 ? null : round(pass, 4));
                setValOrBlank(sheet, r0, 3, yoyOf(pass, lastPass));
                setValOrBlank(sheet, r0, 5, turn == 0 ? null : round(turn, 4));
                setValOrBlank(sheet, r0, 7, yoyOf(turn, lastTurn));
            }
            recalc(wb);
            return toBytes(wb);
        }
    }

    /** å†™æ•°å€¼æˆ–清空（公式单元格保留不动） */
    private void setValOrBlank(Sheet sheet, int r0, int c0, Double v) {
        Row row = sheet.getRow(r0);
        if (row == null) return;
        Cell c = row.getCell(c0);
        if (c == null) return;
        if (c.getCellType() == CellType.FORMULA) return;
        if (v == null || v == 0.0) c.setBlank(); else c.setCellValue(v);
    }

    private Double yoyOf(double cur, double base) {
        if (base == 0.0) return null;
        return round((cur - base) / base, 4);
    }

    /** ä¸­å£å¾„分类累计（1..monthCount æœˆæ±‚和） */
    private double midCumClass(Map<Integer, Map<String, double[][]>> mid, int year, String area, int monthCount, int k, boolean volume) {
        double sum = 0.0;
        boolean has = false;
        for (int m = 1; m <= monthCount; m++) {
            Map<String, double[][]> mm = mid.get(year * 100 + m);
            if (mm == null) continue;
            double[][] arr = mm.get(area);
            if (arr == null) continue;
            sum += volume ? arr[k][0] : arr[k][1];
            has = true;
        }
        return has ? sum : 0.0;
    }

    /**
     * ç”Ÿæˆ_中口径分析.xlsx：以样例为底稿，填累计客运量/周转量/同比，占比公式保留。
     */
    public byte[] exportPassengerMidAnalysis(String period, String mode) throws Exception {
        int maxMonth = monthOf(period, mode);
        int currentYear = Integer.parseInt(period.substring(0, 4));
        File template = resolvePassengerTemplate("生成_中口径分析.xlsx");
        try (InputStream in = new FileInputStream(template);
             XSSFWorkbook wb = new XSSFWorkbook(in)) {
            Sheet sheet = wb.getSheetAt(0);
            Map<Integer, Map<String, double[][]>> mid = loadMidClassMap();
            Row title = sheet.getRow(0);
            if (title != null && title.getCell(0) != null) {
                title.getCell(0).setCellValue(currentYear + "å¹´" + cumRange(maxMonth) + "中口径客运量及周转量");
            }
            // r3=总 r4=班线 r5=公交 r6=出租 r7=网约车（1-based）；列 B/C/F/G å¡«å€¼ï¼ŒD/H å æ¯”公式保留
            String[] names = {"总客运量", "公路班线", "城际城乡公交", "城际城乡巡游出租", "城际城乡网约车"};
            int[] dims = {0, 1, 2, 3, 4};
            for (int i = 0; i < names.length; i++) {
                int r0 = 2 + i;
                double pass = midCumClass(mid, currentYear, "湖北省", maxMonth, dims[i], true);
                double turn = midCumClass(mid, currentYear, "湖北省", maxMonth, dims[i], false);
                double lastPass = midCumClass(mid, currentYear - 1, "湖北省", maxMonth, dims[i], true);
                double lastTurn = midCumClass(mid, currentYear - 1, "湖北省", maxMonth, dims[i], false);
                setValOrBlank(sheet, r0, 1, pass == 0 ? null : round(pass, 4));
                setValOrBlank(sheet, r0, 2, yoyOf(pass, lastPass));
                setValOrBlank(sheet, r0, 5, turn == 0 ? null : round(turn, 4));
                setValOrBlank(sheet, r0, 6, yoyOf(turn, lastTurn));
            }
            recalc(wb);
            return toBytes(wb);
        }
    }

    private double nvlOf(Double v) {
        return v == null ? Double.NaN : v;
    }

    private Double numOrNull(double v) {
        return Double.isNaN(v) ? null : v;
    }

    /** é™åºæŽ’名（无数据 NaN æŽ’最后），返回各下标对应名次 */
    private int[] rankValues(double[] values) {
        Integer[] order = new Integer[values.length];
        for (int i = 0; i < values.length; i++) order[i] = i;
        java.util.Arrays.sort(order, (a, b) -> {
            boolean na = Double.isNaN(values[a]);
            boolean nb = Double.isNaN(values[b]);
            if (na && nb) return 0;
            if (na) return 1;
            if (nb) return -1;
            return Double.compare(values[b], values[a]);
        });
        int[] ranks = new int[values.length];
        for (int i = 0; i < order.length; i++) ranks[order[i]] = i + 1;
        return ranks;
    }

    // ==================== 5. ç”Ÿæˆ_能运汇总表（H204 é“路货运车辆能源消耗情况） ====================

    /** ç‡ƒæ–™ç±»åž‹ç  -> å‘¨è½¬é‡å•è€—折算系数（千克标准煤折算） */
    private static final Map<String, Double> ENERGY_FUEL_COEFF = new HashMap<>();

    static {
        ENERGY_FUEL_COEFF.put("01", 0.73 * 1.4714);      // æ±½æ²¹
        ENERGY_FUEL_COEFF.put("02", 0.86 * 1.4571);      // æŸ´æ²¹
        ENERGY_FUEL_COEFF.put("03", 1.7572);             // åŽ‹ç¼©å¤©ç„¶æ°”
        ENERGY_FUEL_COEFF.put("04", 1.7572);             // æ¶²åŒ–天然气
        ENERGY_FUEL_COEFF.put("07", 0.1229);             // ç”µåŠ¨
        ENERGY_FUEL_COEFF.put("08", 0.3329 * 12.1951);   // ç‡ƒæ–™ç”µæ± ï¼ˆæ°¢æ°”）
    }

    /** ç‡ƒæ–™ç  -> æ±‡æ€»è¡¨è¡Œåï¼ˆä¸Žæ¨¡æ¿è¡Œé¡ºåºä¸€è‡´ï¼‰ */
    private static final String[][] ENERGY_FUEL_ROWS = {
        {"柴油车", "02"},
        {"汽油车", "01"},
        {"液化天然气车", "04"},
        {"压缩天然气车", "03"},
        {"纯电动车", "07"},
        {"燃料电池车", "08"}
    };

    /**
     * èƒ½è¿æ±‡æ€»è¡¨ï¼šæŒ‰ç‡ƒæ–™ç±»åž‹åˆ†ç»„汇总，全省 + å„市州各一张 sheet
     */
    public byte[] exportEnergySummary(String period) throws Exception {
        List<EnergyVehicleQuarterly> list = energyMapper.selectList(
            new LambdaQueryWrapper<EnergyVehicleQuarterly>()
                .eq(EnergyVehicleQuarterly::getReportPeriod, period));
        int quarter = (parseMonth(period) + 2) / 3;
        String[] QUARTER_CN = {"一", "二", "三", "四"};
        String title = period.substring(0, 4) + "年第" + QUARTER_CN[quarter - 1] + "季度能耗汇总情况表";

        Map<String, FuelAgg> province = new HashMap<>();
        Map<String, Map<String, FuelAgg>> cityMap = new HashMap<>();
        for (EnergyVehicleQuarterly e : list) {
            String code = e.getFuelTypeCode();
            if (code == null || code.trim().isEmpty()) continue;
            province.computeIfAbsent(code.trim(), k -> new FuelAgg()).add(e);
            String city = RegionUtil.cityByCode(e.getRegionCode());
            if (city != null) {
                cityMap.computeIfAbsent(city, k -> new HashMap<>())
                    .computeIfAbsent(code.trim(), k2 -> new FuelAgg()).add(e);
            }
        }

        // ä»¥ æ¨¡æ¿_能运汇总表 .xlsx ä¸ºåº•ç¨¿ï¼šä¿ç•™æ ‡é¢˜/表头/合并/公式/列宽/样式，仅替换数据区数值
        File template = resolveAnyTemplate(energyTemplateDir, "生成_能运汇总表.xlsx");
        try (InputStream in = new FileInputStream(template);
             XSSFWorkbook wb = new XSSFWorkbook(in)) {
            Sheet base = wb.getSheetAt(0);
            base.getRow(0).getCell(0).setCellValue(title);
            fillEnergyTemplateSheet(base, province);
            for (String city : RegionUtil.cityList()) {
                Map<String, FuelAgg> agg = cityMap.get(city);
                if (agg == null || agg.isEmpty()) continue;
                Sheet s = wb.cloneSheet(0);
                wb.setSheetName(wb.getSheetIndex(s), RegionUtil.shortName(city) + "能耗汇总");
                s.getRow(0).getCell(0).setCellValue(title);
                fillEnergyTemplateSheet(s, agg);
            }
            recalc(wb);
            return toBytes(wb);
        }
    }

    /** èƒ½è€—汇总模板填充：1-based ç¬¬3~8行为 æŸ´æ²¹/汽油/液化天然/压缩天然/纯电/燃料电池；D/J/L/M ä¸ºå…¬å¼åˆ—，仅填数值列 */
    private void fillEnergyTemplateSheet(Sheet sheet, Map<String, FuelAgg> data) {
        for (int i = 0; i < ENERGY_FUEL_ROWS.length; i++) {
            Row row = sheet.getRow(2 + i);
            if (row == null) row = sheet.createRow(2 + i);
            FuelAgg agg = data.get(ENERGY_FUEL_ROWS[i][1]);
            if (agg == null || agg.count == 0) {
                setEnergyValue(row, 1, null);
                setEnergyValue(row, 2, null);
                setEnergyValue(row, 4, null);
                setEnergyValue(row, 5, null);
                setEnergyValue(row, 6, null);
                setEnergyValue(row, 7, null);
                setEnergyValue(row, 8, null);
                setEnergyValue(row, 10, null);
                continue;
            }
            setEnergyValue(row, 1, (double) agg.count);
            setEnergyValue(row, 2, agg.totalTonnage);
            setEnergyValue(row, 4, agg.totalMileage);
            setEnergyValue(row, 5, agg.loadedMileage);
            setEnergyValue(row, 6, agg.emptyMileage);
            setEnergyValue(row, 7, agg.freight);
            setEnergyValue(row, 8, agg.turnover);
            setEnergyValue(row, 10, agg.fuelConsumption);
        }
    }

    /** å†™èƒ½è€—数值列：有值写入，无值清空模板样例；公式列（D/J/L/M）不动 */
    private void setEnergyValue(Row row, int colIdx, Double v) {
        Cell c = row.getCell(colIdx);
        if (c != null && c.getCellType() == org.apache.poi.ss.usermodel.CellType.FORMULA) return;
        if (c == null) c = row.createCell(colIdx);
        if (v == null) c.setBlank(); else c.setCellValue(v);
    }

    /** èƒ½è€—汇总：按燃料类型聚合 */
    private static class FuelAgg {
        int count;
        double totalTonnage;
        double totalMileage;
        double loadedMileage;
        double emptyMileage;
        double freight;
        double turnover;
        double fuelConsumption;

        void add(EnergyVehicleQuarterly e) {
            count++;
            totalTonnage += nz(e.getMarkedTonnage());
            totalMileage += nz(e.getTotalMileage());
            loadedMileage += nz(e.getLoadedMileage());
            emptyMileage += nz(e.getEmptyMileage());
            freight += nz(e.getFreight());
            turnover += nz(e.getTurnover());
            fuelConsumption += nz(e.getFuelConsumption());
        }

        private double nz(Double v) {
            return v == null ? 0.0 : v;
        }
    }

    // ==================== é€šç”¨è¾…助 ====================

    private int parseMonth(String period) {
        return Integer.parseInt(period.split("-")[1]);
    }

    private int monthOf(String period, String mode) {
        return "year".equalsIgnoreCase(mode) ? 12 : parseMonth(period);
    }

    /** ç´¯è®¡åŒºé—´æ–‡æ¡ˆï¼š1 æœˆæ˜¾ç¤º "1月"，其余显示 "1-N月"（避免出现 "1-1月"） */
    private String cumRange(int month) {
        return month <= 1 ? "1月" : "1-" + month + "月";
    }

    /** æ—…客分市州/中口径明细模板表头年份动态化：把 "2026å¹´1月"…"2026å¹´6月"、"2026年累计" çš„年份换成所选年 */
    private void fixPassengerHeaderYear(Sheet sheet, int year) {
        java.util.regex.Pattern p = java.util.regex.Pattern.compile("^\\d{4}å¹´");
        for (int r = 1; r <= 3; r++) {
            Row row = sheet.getRow(r);
            if (row == null) continue;
            for (Cell cell : row) {
                if (cell.getCellType() != CellType.STRING) continue;
                String v = cell.getStringCellValue();
                if (v == null || v.isEmpty()) continue;
                String nv = p.matcher(v).replaceFirst(year + "å¹´");
                if (!nv.equals(v)) cell.setCellValue(nv);
            }
        }
    }

    private String pad(int m) {
@@ -808,6 +2501,1372 @@
        sheet.setColumnWidth(1, 22 * 256);
    }


    // ==================== åŸŽå¸‚客运（公交）分市州明细 ====================

    /** ç”Ÿæˆ_城市公交客运量分市州明细.xlsx（以 åŸŽå¸‚公交_模板.xlsx ä¸ºåº•ç¨¿ï¼Œä¿ç•™æ¨¡æ¿æ ¼å¼ä¸Žå…¬å¼ï¼‰ */
    public byte[] exportCityBusDetail(String period, String mode) throws Exception {
        int year = Integer.parseInt(period.split("-")[0]);
        int month = monthOf(period, mode);
        return exportCityByTemplate("导入模板_城市公交.xlsx", period, mode,
            loadCityBusByMonth(year + "-", month),
            loadCityBusByMonth((year - 1) + "-", month));
    }
    /** åŠ è½½æŸå¹´ 1..limit æœˆåŸŽå¸‚公交企业数据，按 æœˆ â†’ å¸‚å·ž â†’ [客运量,周转量,城市内客运量,城市内周转量] æ±‡æ€»ï¼›"全省" ä¸ºå…¨éƒ¨å¸‚州合计 */
    private Map<Integer, Map<String, double[]>> loadCityBusByMonth(String yearPrefix, int limit) {
        Map<Integer, Map<String, double[]>> monthCity = new java.util.LinkedHashMap<>();
        List<CityBusMonthly> rows = cityBusMapper.selectList(
            new LambdaQueryWrapper<CityBusMonthly>()
                .likeRight(CityBusMonthly::getReportPeriod, yearPrefix));
        for (CityBusMonthly r : rows) {
            int m = monthOf(r.getReportPeriod());
            if (m < 1 || m > limit) continue;
            String city = r.getCity() == null ? "未知" : r.getCity();
            Map<String, double[]> cityMap = monthCity.computeIfAbsent(m, k -> new HashMap<>());
            double[] arr = cityMap.computeIfAbsent(city, k -> new double[4]);
            arr[0] += nz(r.getPassengerVolume());
            arr[1] += nz(r.getTurnover());
            arr[2] += nz(r.getPassengerCity());
            arr[3] += nz(r.getTurnoverCity());
            double[] prov = cityMap.computeIfAbsent("全省", k -> new double[4]);
            prov[0] += nz(r.getPassengerVolume());
            prov[1] += nz(r.getTurnover());
            prov[2] += nz(r.getPassengerCity());
            prov[3] += nz(r.getTurnoverCity());
        }
        return monthCity;
    }

    private int monthOf(String reportPeriod) {
        if (reportPeriod == null) return 0;
        String[] parts = reportPeriod.split("-");
        if (parts.length < 2) return 0;
        try {
            return Integer.parseInt(parts[1]);
        } catch (Exception e) {
            return 0;
        }
    }

    private double cityBusVal(Map<Integer, Map<String, double[]>> monthCity, String area, int m, int idx) {
        Map<String, double[]> cityMap = monthCity.get(m);
        if (cityMap == null) return 0;
        double[] arr = cityMap.get(area);
        if (arr == null) return 0;
        return idx < arr.length ? arr[idx] : 0;
    }

    // ==================== åŸŽå¸‚客运（巡游出租）分市州明细 ====================

    /** ç”Ÿæˆ_巡游出租客运量分市州明细.xlsx（以 å·¡æ¸¸å‡ºç§Ÿ_模板.xlsx ä¸ºåº•ç¨¿ï¼Œä¿ç•™æ¨¡æ¿æ ¼å¼ä¸Žå…¬å¼ï¼‰ */
    public byte[] exportCityTaxiDetail(String period, String mode) throws Exception {
        int year = Integer.parseInt(period.split("-")[0]);
        int month = monthOf(period, mode);
        return exportCityByTemplate("导入模板_巡游出租.xlsx", period, mode,
            loadCityTaxiByMonth(year + "-", month),
            loadCityTaxiByMonth((year - 1) + "-", month));
    }
    /** åŠ è½½æŸå¹´ 1..limit æœˆå·¡æ¸¸å‡ºç§Ÿæ•°æ®ï¼ŒæŒ‰ æœˆ â†’ å¸‚å·ž â†’ [客运量,周转量,城市内客运量,城市内周转量] æ±‡æ€»ï¼›"全省" ä¸ºå…¨éƒ¨å¸‚州合计 */
    private Map<Integer, Map<String, double[]>> loadCityTaxiByMonth(String yearPrefix, int limit) {
        Map<Integer, Map<String, double[]>> monthCity = new java.util.LinkedHashMap<>();
        List<CityTaxiMonthly> rows = cityTaxiMapper.selectList(
            new LambdaQueryWrapper<CityTaxiMonthly>()
                .likeRight(CityTaxiMonthly::getReportPeriod, yearPrefix));
        for (CityTaxiMonthly r : rows) {
            int m = monthOf(r.getReportPeriod());
            if (m < 1 || m > limit) continue;
            String city = r.getCity() == null ? "未知" : r.getCity();
            Map<String, double[]> cityMap = monthCity.computeIfAbsent(m, k -> new HashMap<>());
            double[] arr = cityMap.computeIfAbsent(city, k -> new double[4]);
            arr[0] += nz(r.getPassengerVolume());
            arr[1] += nz(r.getTurnover());
            arr[2] += nz(r.getPassengerCity());
            arr[3] += nz(r.getTurnoverCity());
            double[] prov = cityMap.computeIfAbsent("全省", k -> new double[4]);
            prov[0] += nz(r.getPassengerVolume());
            prov[1] += nz(r.getTurnover());
            prov[2] += nz(r.getPassengerCity());
            prov[3] += nz(r.getTurnoverCity());
        }
        return monthCity;
    }

    private double cityTaxiVal(Map<Integer, Map<String, double[]>> monthCity, String area, int m, int idx) {
        Map<String, double[]> cityMap = monthCity.get(m);
        if (cityMap == null) return 0;
        double[] arr = cityMap.get(area);
        if (arr == null) return 0;
        return idx < arr.length ? arr[idx] : 0;
    }

    // ==================== åŸŽå¸‚客运（轨道/轮渡）分市州明细 ====================

    /** ç”Ÿæˆ_轨道轮渡客运量分市州明细.xlsx（以 è½¨é“、轮渡_模板.xlsx ä¸ºåº•ç¨¿ï¼Œè½¨é“=全省/武汉/黄石，轮渡=全省/武汉） */
    public byte[] exportCityRailFerryDetail(String period, String mode) throws Exception {
        int year = Integer.parseInt(period.split("-")[0]);
        int month = monthOf(period, mode);
        Map<Integer, Map<String, double[]>> monthCity = loadCityRailFerryByMonth(year + "-", month);
        File template = resolveTemplate("导入模板_轨道、轮渡.xlsx");
        try (InputStream in = new FileInputStream(template);
             XSSFWorkbook wb = new XSSFWorkbook(in)) {
            Sheet sheet = wb.getSheetAt(0);
            dynamicTitle(sheet, year, month); // æ ‡é¢˜æŒ‰æŠ¥è¡¨æœŸåŠ¨æ€åŒ–（不写死年份/月份）
            // è½¨é“：客运量行 4(全省)/6(武汉)/8(黄石)，周转量行为 +1；指标 0=轨道客运量 1=轨道周转量
            fillRailFerryBlock(sheet, monthCity, month, new String[][]{{"全省", "3"}, {"武汉市", "5"}, {"黄石市", "7"}}, 0);
            // è½®æ¸¡ï¼šå®¢è¿é‡è¡Œ 13(全省)/15(武汉)；指标 2=轮渡客运量 3=轮渡周转量
            fillRailFerryBlock(sheet, monthCity, month, new String[][]{{"全省", "12"}, {"武汉市", "14"}}, 2);
            recalc(wb);
            return toBytes(wb);
        }
    }

    /** åŠ è½½æŸå¹´ 1..limit æœˆè½¨é“/轮渡数据：月 â†’ å¸‚å·ž â†’ [轨道客运量,轨道周转量,轮渡客运量,轮渡周转量]，含"全省" */
    private Map<Integer, Map<String, double[]>> loadCityRailFerryByMonth(String yearPrefix, int limit) {
        Map<Integer, Map<String, double[]>> monthCity = new java.util.LinkedHashMap<>();
        List<CityBusMonthly> rows = cityBusMapper.selectList(
            new LambdaQueryWrapper<CityBusMonthly>().likeRight(CityBusMonthly::getReportPeriod, yearPrefix));
        for (CityBusMonthly r : rows) {
            int m = monthOf(r.getReportPeriod());
            if (m < 1 || m > limit) continue;
            String city = r.getCity() == null ? "未知" : r.getCity();
            Map<String, double[]> cityMap = monthCity.computeIfAbsent(m, k -> new HashMap<>());
            double[] arr = cityMap.computeIfAbsent(city, k -> new double[4]);
            arr[0] += nz(r.getRailPassengerVolume());
            arr[1] += nz(r.getRailTurnover());
            arr[2] += nz(r.getFerryPassengerVolume());
            arr[3] += nz(r.getFerryTurnover());
            double[] prov = cityMap.computeIfAbsent("全省", k -> new double[4]);
            prov[0] += nz(r.getRailPassengerVolume());
            prov[1] += nz(r.getRailTurnover());
            prov[2] += nz(r.getFerryPassengerVolume());
            prov[3] += nz(r.getFerryTurnover());
        }
        return monthCity;
    }

    /** å¡«å……轨道/轮渡块：baseIdx ä¸ºå®¢è¿é‡æŒ‡æ ‡ï¼Œå‘¨è½¬é‡æŒ‡æ ‡ = baseIdx+1；2026 æœˆåº¦åˆ— C..O，2025 åˆ— T.. æ— æ•°æ®åˆ™æ¸…空 */
    private void fillRailFerryBlock(Sheet sheet, Map<Integer, Map<String, double[]>> monthCity, int month,
                                    String[][] areaRows, int baseIdx) {
        for (String[] ar : areaRows) {
            String area = ar[0];
            int paxRow = Integer.parseInt(ar[1]);
            for (int m = 1; m <= month; m++) {
                setDataCell(sheet, paxRow, 2 + (m - 1) * 2, railFerryVal(monthCity, area, m, baseIdx));
                setDataCell(sheet, paxRow + 1, 2 + (m - 1) * 2, railFerryVal(monthCity, area, m, baseIdx + 1));
            }
            for (int m = 1; m <= 12; m++) {
                setDataCell(sheet, paxRow, 19 + (m - 1) * 2, 0);
                setDataCell(sheet, paxRow + 1, 19 + (m - 1) * 2, 0);
            }
        }
    }

    private double railFerryVal(Map<Integer, Map<String, double[]>> monthCity, String area, int m, int idx) {
        Map<String, double[]> cityMap = monthCity.get(m);
        if (cityMap == null) return 0;
        double[] arr = cityMap.get(area);
        if (arr == null) return 0;
        return idx < arr.length ? arr[idx] : 0;
    }

    /** å†™æ•°æ®å•å…ƒæ ¼ï¼šåŽŸä¸ºå…¬å¼åˆ™ä¿ç•™ï¼ˆå…¨çœæ±‚å’Œ/排名公式）；否则有值写入、无值清空模板样例 */
    private void setDataCell(Sheet sheet, int rowIdx, int colIdx, double v) {
        Row row = sheet.getRow(rowIdx);
        if (row == null) row = sheet.createRow(rowIdx);
        Cell c = row.getCell(colIdx);
        if (c != null && c.getCellType() == org.apache.poi.ss.usermodel.CellType.FORMULA) return;
        if (c == null) c = row.createCell(colIdx);
        if (v == 0) c.setBlank(); else c.setCellValue(round(v, 2));
    }

    /** æ˜¾å¼å†™å…¥ 0（setDataCell å¯¹ 0 ç½®ç©ºï¼›æ±‡æ€»è¡¨ç½‘约车行需要显示 0） */
    private void setZeroCell(Sheet sheet, int rowIdx, int colIdx) {
        Row row = sheet.getRow(rowIdx);
        if (row == null) row = sheet.createRow(rowIdx);
        Cell c = row.getCell(colIdx);
        if (c != null && c.getCellType() == org.apache.poi.ss.usermodel.CellType.FORMULA) return;
        if (c == null) c = row.createCell(colIdx);
        c.setCellValue(0.0);
    }
    /** é‡ç®—公式缓存值（保留公式，求值异常忽略） */
    private void recalc(XSSFWorkbook wb) {
        try {
            wb.getCreationHelper().createFormulaEvaluator().evaluateAll();
        } catch (Exception e) {
            log.warn("城市客运模板公式求值失败: {}", e.getMessage());
        }
    }

    // ==================== åŸŽå¸‚客运 åˆ†å¸‚州累计（城市分市州_模板 / åŸŽå¸‚客运各市州明细表_模板） ====================

    /** ç”Ÿæˆ_城市客运客运量分市州累计.xlsx（以 åŸŽå¸‚分市州_模板.xlsx / åŸŽå¸‚客运各市州明细表_模板.xlsx ä¸ºåº•ç¨¿ï¼›ç½‘约车列无源数据留空） */
    public byte[] exportCityPassengerCitySum(String templateFileName, String period, String mode) throws Exception {
        int year = Integer.parseInt(period.split("-")[0]);
        int month = monthOf(period, mode);
        Map<String, double[]> cum = loadCityPassengerCumulative(year + "-", month);
        File template = resolveTemplate(templateFileName);
        try (InputStream in = new FileInputStream(template);
             XSSFWorkbook wb = new XSSFWorkbook(in)) {
            Sheet sheet = wb.getSheetAt(0);
            dynamicTitle(sheet, year, month); // æ ‡é¢˜æŒ‰æŠ¥è¡¨æœŸåŠ¨æ€åŒ–
            List<String> areas = new java.util.ArrayList<>();
            areas.add("全省");
            areas.addAll(RegionUtil.cityList());
            fillCitySumBlock(sheet, cum, areas, 4, 0);   // å®¢è¿é‡åŒºï¼ˆå•ä½ï¼šä¸‡äººæ¬¡ï¼ŒPOI 0 åŸºï¼‰
            fillCitySumBlock(sheet, cum, areas, 26, 1);  // å‘¨è½¬é‡åŒºï¼ˆå•ä½ï¼šä¸‡äººæ¬¡å…¬é‡Œï¼ŒPOI 0 åŸºï¼‰
            recalc(wb);
            return toBytes(wb);
        }
    }

    /** å¡«å……一个累计区：startRow èµ·æ¯åœ°åŒº 1 è¡Œï¼›paxTurnIdx=0 ç”¨å®¢è¿é‡ã€1 ç”¨å‘¨è½¬é‡ */
    private void fillCitySumBlock(Sheet sheet, Map<String, double[]> cum, List<String> areas, int startRow, int paxTurnIdx) {
        int rowIdx = startRow;
        for (String area : areas) {
            double[] v = cum.get(area);
            double bus = v == null ? 0 : v[paxTurnIdx == 0 ? 0 : 1];
            double taxi = v == null ? 0 : v[paxTurnIdx == 0 ? 2 : 3];
            double rail = v == null ? 0 : v[paxTurnIdx == 0 ? 4 : 5];
            double ferry = v == null ? 0 : v[paxTurnIdx == 0 ? 6 : 7];
            double total = bus + taxi + rail + ferry; // ç½‘约车无源数据，不计
            setDataCell(sheet, rowIdx, 1, total);   // B æ€»ç´¯è®¡
            setDataCell(sheet, rowIdx, 6, bus);     // G å…¬äº¤
            setDataCell(sheet, rowIdx, 11, taxi);   // L å‡ºç§Ÿ
            setDataCell(sheet, rowIdx, 16, 0);      // Q ç½‘约车（无源数据→清空样例）
            setDataCell(sheet, rowIdx, 21, rail);   // V è½¨é“
            setDataCell(sheet, rowIdx, 23, ferry);  // X è½®æ¸¡
            // å¢žé€Ÿåˆ— E/J/O/T/W/Y：无去年同期累计 â†’ æ¸…空模板样例（排名/占比公式保留）
            setDataCell(sheet, rowIdx, 4, 0);
            setDataCell(sheet, rowIdx, 9, 0);
            setDataCell(sheet, rowIdx, 14, 0);
            setDataCell(sheet, rowIdx, 19, 0);
            setDataCell(sheet, rowIdx, 22, 0);
            setDataCell(sheet, rowIdx, 24, 0);
            rowIdx++;
        }
    }

    /** æŸå¹´ 1..limit æœˆåŸŽå¸‚客运累计：city â†’ [公交客运量,公交周转量,出租客运量,出租周转量,轨道客运量,轨道周转量,轮渡客运量,轮渡周转量]，含"全省" */
    private Map<String, double[]> loadCityPassengerCumulative(String yearPrefix, int limit) {
        Map<String, double[]> cum = new HashMap<>();
        for (CityBusMonthly r : cityBusMapper.selectList(
                new LambdaQueryWrapper<CityBusMonthly>().likeRight(CityBusMonthly::getReportPeriod, yearPrefix))) {
            int m = monthOf(r.getReportPeriod());
            if (m < 1 || m > limit) continue;
            String city = r.getCity() == null ? "未知" : r.getCity();
            double[] a = cum.computeIfAbsent(city, k -> new double[8]);
            a[0] += nz(r.getPassengerVolume());
            a[1] += nz(r.getTurnover());
            a[4] += nz(r.getRailPassengerVolume());
            a[5] += nz(r.getRailTurnover());
            a[6] += nz(r.getFerryPassengerVolume());
            a[7] += nz(r.getFerryTurnover());
            double[] p = cum.computeIfAbsent("全省", k -> new double[8]);
            p[0] += nz(r.getPassengerVolume());
            p[1] += nz(r.getTurnover());
            p[4] += nz(r.getRailPassengerVolume());
            p[5] += nz(r.getRailTurnover());
            p[6] += nz(r.getFerryPassengerVolume());
            p[7] += nz(r.getFerryTurnover());
        }
        for (CityTaxiMonthly r : cityTaxiMapper.selectList(
                new LambdaQueryWrapper<CityTaxiMonthly>().likeRight(CityTaxiMonthly::getReportPeriod, yearPrefix))) {
            int m = monthOf(r.getReportPeriod());
            if (m < 1 || m > limit) continue;
            String city = r.getCity() == null ? "未知" : r.getCity();
            double[] a = cum.computeIfAbsent(city, k -> new double[8]);
            a[2] += nz(r.getPassengerVolume());
            a[3] += nz(r.getTurnover());
            double[] p = cum.computeIfAbsent("全省", k -> new double[8]);
            p[2] += nz(r.getPassengerVolume());
            p[3] += nz(r.getTurnover());
        }
        return cum;
    }

    // ==================== åŸŽå¸‚客运 å…¨çœæ±‡æ€»ï¼ˆåŸŽå¸‚汇总_模板） ====================

    /** ç”Ÿæˆ_城市客运汇总.xlsx（以 åŸŽå¸‚汇总_模板.xlsx ä¸ºåº•ç¨¿ï¼›2026 æ®µå¡«åº“内 1..N æœˆç´¯è®¡ï¼ŒåŒæ¯”清空，2025/2024 æ®µä¿ç•™æ¨¡æ¿åŽ†å²å‚考值） */
    public byte[] exportCityPassengerSummary(String period, String mode) throws Exception {
        int year = Integer.parseInt(period.split("-")[0]);
        int month = monthOf(period, mode);
        double[] prov = loadCityPassengerCumulative(year + "-", month).getOrDefault("全省", new double[8]);
        double busPax = prov[0], busTurn = prov[1];
        double taxiPax = prov[2], taxiTurn = prov[3];
        double railPax = prov[4], railTurn = prov[5];
        double ferryPax = prov[6], ferryTurn = prov[7];
        File template = resolveTemplate("导入模板_城市汇总.xlsx");
        try (InputStream in = new FileInputStream(template);
             XSSFWorkbook wb = new XSSFWorkbook(in)) {
            Sheet sheet = wb.getSheetAt(0);
            dynamicTitle(sheet, year, month); // æ ‡é¢˜æŒ‰æŠ¥è¡¨æœŸåŠ¨æ€åŒ–
            // è¡Œ3 æ€»å®¢è¿é‡=公交+出租车(巡游+网约车)+轨道+轮渡；行4 å…¬äº¤ï¼›è¡Œ5 å‡ºç§Ÿè½¦=巡游+网约车；行6 å·¡æ¸¸ï¼›è¡Œ7 ç½‘约车；行8 è½¨é“；行9 è½®æ¸¡
            setDataCell(sheet, 2, 1, busPax + taxiPax + railPax + ferryPax); // B3（POI 0 åŸºè¡Œ2）
            setDataCell(sheet, 2, 3, busTurn + taxiTurn + railTurn + ferryTurn); // D3
            setDataCell(sheet, 3, 1, busPax);   // B4 åŸŽå¸‚公交
            setDataCell(sheet, 3, 3, busTurn);  // D4
            setDataCell(sheet, 4, 1, taxiPax);  // B5 åŸŽå¸‚出租车（网约车无源数据）
            setDataCell(sheet, 4, 3, taxiTurn); // D5
            setDataCell(sheet, 5, 1, taxiPax);  // B6 å…¶ä¸­å·¡æ¸¸å‡ºç§Ÿ
            setDataCell(sheet, 5, 3, taxiTurn); // D6
            setZeroCell(sheet, 6, 1);           // B7 åŸŽå¸‚网约车（显式 0，setDataCell å¯¹ 0 ä¼šç½®ç©ºï¼‰
            setZeroCell(sheet, 6, 3);           // D7
            setDataCell(sheet, 7, 1, railPax);  // B8 è½¨é“
            setDataCell(sheet, 7, 3, railTurn); // D8
            setDataCell(sheet, 8, 1, ferryPax); // B9 è½®æ¸¡
            setDataCell(sheet, 8, 3, ferryTurn);// D9
            for (int r = 2; r <= 8; r++) {      // åŒæ¯” C/E：无去年同期 â†’ æ¸…空样例
                setDataCell(sheet, r, 2, 0);
                setDataCell(sheet, r, 4, 0);
            }
            recalc(wb);
            return toBytes(wb);
        }
    }

    // ==================== åŸŽå¸‚客运 æŠ¥è¡¨ç³»åˆ—（一键打包） ====================

    /** ç”Ÿæˆ_城市客运报表系列.zip：公交/出租/轨道轮渡明细 + åˆ†å¸‚州累计 + å„市州明细表 + æ±‡æ€» */
    public byte[] exportCityPassengerSeries(String period, String mode) throws Exception {
        java.io.ByteArrayOutputStream bos = new java.io.ByteArrayOutputStream();
        try (java.util.zip.ZipOutputStream zos = new java.util.zip.ZipOutputStream(bos)) {
            addZipEntry(zos, "生成_城市公交客运量分市州明细.xlsx", exportCityBusDetail(period, mode));
            addZipEntry(zos, "生成_巡游出租客运量分市州明细.xlsx", exportCityTaxiDetail(period, mode));
            addZipEntry(zos, "生成_轨道轮渡客运量分市州明细.xlsx", exportCityRailFerryDetail(period, mode));
            addZipEntry(zos, "生成_城市客运客运量分市州累计.xlsx", exportCityPassengerCitySum("导入模板_城市分市州.xlsx", period, mode));
            addZipEntry(zos, "生成_城市客运各市州明细表.xlsx", exportCityPassengerCitySum("导入模板_城市客运各市州明细表.xlsx", period, mode));
            addZipEntry(zos, "生成_城市客运汇总.xlsx", exportCityPassengerSummary(period, mode));
        }
        return bos.toByteArray();
    }

    /** ç”Ÿæˆ_货运报表系列.zip：货运量分市州明细 + è´§è¿é‡æŽ’名 + å‘¨è½¬é‡æŽ’名 */
    public byte[] exportFreightSeries(String period, String mode) throws Exception {
        java.io.ByteArrayOutputStream bos = new java.io.ByteArrayOutputStream();
        try (java.util.zip.ZipOutputStream zos = new java.util.zip.ZipOutputStream(bos)) {
            addZipEntry(zos, "生成_货运量分市州明细.xlsx", exportCityDetail(period, mode));
            addZipEntry(zos, "生成_货运量排名.xlsx", exportFreightRank(period, mode));
            addZipEntry(zos, "生成_周转量排名.xlsx", exportTurnoverRank(period, mode));
        }
        return bos.toByteArray();
    }

    /** ç”Ÿæˆ_公路旅客报表系列.zip：分市州明细 + ä¸­å£å¾„明细/排名/分析 */
    public byte[] exportPassengerSeries(String period, String mode) throws Exception {
        java.io.ByteArrayOutputStream bos = new java.io.ByteArrayOutputStream();
        try (java.util.zip.ZipOutputStream zos = new java.util.zip.ZipOutputStream(bos)) {
            addZipEntry(zos, "生成_公路旅客分市州.xlsx", exportPassengerCityDetail(period, mode));
            addZipEntry(zos, "生成_中口径明细.xlsx", exportPassengerMidDetail(period, mode));
            addZipEntry(zos, "生成_中口径排名.xlsx", exportPassengerMidRank(period, mode));
            addZipEntry(zos, "生成_中口径分析.xlsx", exportPassengerMidAnalysis(period, mode));
        }
        return bos.toByteArray();
    }

    /** ç”Ÿæˆ_投资报表系列.zip：预安排 + åäº”五 + äº¿å…ƒ + ç»æµŽå¼ºåŽ¿ */
    public byte[] exportInvestSeries(String period, String mode) throws Exception {
        java.io.ByteArrayOutputStream bos = new java.io.ByteArrayOutputStream();
        try (java.util.zip.ZipOutputStream zos = new java.util.zip.ZipOutputStream(bos)) {
            addZipEntry(zos, "生成_全省预安排计划进度情况汇总.xls", investPlan(period, mode));
            addZipEntry(zos, "生成_十五五规划物流项目进展情况.xls", investFiveYearLogistics(period, mode));
            addZipEntry(zos, "生成_湖北省（客货站场）亿元投资项目.xls", investBillion(period, mode));
            addZipEntry(zos, "生成_经济强县交通物流基础设施投资统计报表.xls", investCounty(period, mode));
        }
        return bos.toByteArray();
    }

    /** ç”Ÿæˆ_所选报表.zip：按 type åˆ—表打包（前端"生成选中"多选时用） */
    public byte[] exportSelectedSeries(String period, String mode, List<String> types) throws Exception {
        java.io.ByteArrayOutputStream bos = new java.io.ByteArrayOutputStream();
        try (java.util.zip.ZipOutputStream zos = new java.util.zip.ZipOutputStream(bos)) {
            if (types != null) {
                for (String t : types) {
                    if (t == null || t.trim().isEmpty()) continue;
                    byte[] data = selectedReportData(period, mode, t);
                    if (data != null) {
                        String name = REPORT_FILE_NAMES.get(t);
                        if (name == null) name = "生成_" + t + ".xlsx";
                        addZipEntry(zos, name, data);
                    }
                }
            }
        }
        return bos.toByteArray();
    }

    private byte[] selectedReportData(String period, String mode, String type) throws Exception {
        switch (type) {
            case "cityDetail": return exportCityDetail(period, mode);
            case "freightRank": return exportFreightRank(period, mode);
            case "turnoverRank": return exportTurnoverRank(period, mode);
            case "passengerCityDetail": return exportPassengerCityDetail(period, mode);
            case "passengerMidDetail": return exportPassengerMidDetail(period, mode);
            case "passengerMidRank": return exportPassengerMidRank(period, mode);
            case "passengerMidAnalysis": return exportPassengerMidAnalysis(period, mode);
            case "energySummary": return exportEnergySummary(period);
            case "investPlan": return investPlan(period, mode);
            case "investFiveYearLogistics": return investFiveYearLogistics(period, mode);
            case "investBillion": return investBillion(period, mode);
            case "investCounty": return investCounty(period, mode);
            case "cityBusDetail": return exportCityBusDetail(period, mode);
            case "cityTaxiDetail": return exportCityTaxiDetail(period, mode);
            case "cityRailFerryDetail": return exportCityRailFerryDetail(period, mode);
            case "cityPassengerCitySum": return exportCityPassengerCitySum("导入模板_城市分市州.xlsx", period, mode);
            case "cityPassengerDetailSum": return exportCityPassengerCitySum("导入模板_城市客运各市州明细表.xlsx", period, mode);
            case "cityPassengerSummary": return exportCityPassengerSummary(period, mode);
            default: return null;
        }
    }

    private static final Map<String, String> REPORT_FILE_NAMES = new HashMap<>();
    static {
        REPORT_FILE_NAMES.put("cityDetail", "生成_货运量分市州明细.xlsx");
        REPORT_FILE_NAMES.put("freightRank", "生成_货运量排名.xlsx");
        REPORT_FILE_NAMES.put("turnoverRank", "生成_周转量排名.xlsx");
        REPORT_FILE_NAMES.put("passengerCityDetail", "生成_公路旅客分市州明细.xlsx");
        REPORT_FILE_NAMES.put("passengerMidDetail", "生成_公路旅客中口径明细.xlsx");
        REPORT_FILE_NAMES.put("passengerMidRank", "生成_公路旅客中口径排名.xlsx");
        REPORT_FILE_NAMES.put("passengerMidAnalysis", "生成_公路旅客中口径分析.xlsx");
        REPORT_FILE_NAMES.put("energySummary", "生成_能运汇总表.xlsx");
        REPORT_FILE_NAMES.put("investPlan", "生成_全省预安排计划进度情况汇总.xls");
        REPORT_FILE_NAMES.put("investFiveYearLogistics", "生成_十五五规划物流项目进展情况.xls");
        REPORT_FILE_NAMES.put("investBillion", "生成_湖北省（客货站场）亿元投资项目.xls");
        REPORT_FILE_NAMES.put("investCounty", "生成_经济强县交通物流基础设施投资统计报表.xls");
        REPORT_FILE_NAMES.put("cityBusDetail", "生成_城市公交客运量分市州明细.xlsx");
        REPORT_FILE_NAMES.put("cityTaxiDetail", "生成_巡游出租客运量分市州明细.xlsx");
        REPORT_FILE_NAMES.put("cityRailFerryDetail", "生成_轨道轮渡客运量分市州明细.xlsx");
        REPORT_FILE_NAMES.put("cityPassengerCitySum", "生成_城市客运客运量分市州累计.xlsx");
        REPORT_FILE_NAMES.put("cityPassengerDetailSum", "生成_城市客运各市州明细表.xlsx");
        REPORT_FILE_NAMES.put("cityPassengerSummary", "生成_城市客运汇总.xlsx");
    }

    private void addZipEntry(java.util.zip.ZipOutputStream zos, String name, byte[] data) throws Exception {
        zos.putNextEntry(new java.util.zip.ZipEntry(name));
        zos.write(data);
        zos.closeEntry();
    }

    /** åŸŽå¸‚客运模板填充：以目录下模板为底稿，保留标题/表头/合并/公式/样式，仅替换数据区市州月度值 */
    public byte[] exportCityByTemplate(String templateFileName, String period, String mode,
                                       Map<Integer, Map<String, double[]>> monthCity,
                                       Map<Integer, Map<String, double[]>> lastYearMonthCity) throws Exception {
        int month = monthOf(period, mode);
        int year = Integer.parseInt(period.split("-")[0]);
        File template = resolveTemplate(templateFileName);
        try (InputStream in = new FileInputStream(template);
             XSSFWorkbook wb = new XSSFWorkbook(in)) {
            Sheet sheet = wb.getSheetAt(0);
            dynamicTitle(sheet, year, month); // æ ‡é¢˜æŒ‰æŠ¥è¡¨æœŸåŠ¨æ€åŒ–（不写死年份/月份）
            // ç»“构守卫：数据区应为 å…¨çœ+17市州 Ã— 4 æŒ‡æ ‡ = 72 è¡Œï¼ˆ1-based ç¬¬5行起）
            if (sheet.getLastRowNum() < 75) {
                throw new RuntimeException("城市客运模板数据区行数不足，请确认模板未改版: " + templateFileName);
            }
            List<String> areas = new java.util.ArrayList<>();
            areas.add("全省");
            areas.addAll(RegionUtil.cityList());
            // æ¨¡æ¿æ•°æ®åŒºï¼š1-based ç¬¬5行起，每地区4行（客运量/周转量/城市内客运量/城市内周转量）
            int rowIdx = 4;
            for (int a = 0; a < areas.size(); a++) {
                String area = areas.get(a);
                for (int k = 0; k < 4; k++) {
                    Row row = sheet.getRow(rowIdx);
                    if (row == null) row = sheet.createRow(rowIdx);
                    if (a > 0) {
                        // 2026å¹´ 1..N æœˆï¼šåº“内有值则填（2位小数），无值清空模板样例
                        for (int m = 1; m <= month; m++) {
                            double v = cityVal(monthCity, area, m, k);
                            Cell c = row.getCell(2 + (m - 1) * 2);
                            if (c == null) c = row.createCell(2 + (m - 1) * 2);
                            if (v == 0) c.setBlank(); else c.setCellValue(round(v, 2));
                        }
                        // 2025å¹´ 1..12 æœˆï¼šåº“内有去年数据则填，否则清空模板样例
                        for (int m = 1; m <= 12; m++) {
                            double v = cityVal(lastYearMonthCity, area, m, k);
                            Cell c = row.getCell(19 + (m - 1) * 2);
                            if (c == null) c = row.createCell(19 + (m - 1) * 2);
                            if (v == 0) c.setBlank(); else c.setCellValue(round(v, 2));
                        }
                    }
                    rowIdx++;
                }
            }
            // é‡ç®—公式缓存值（全省求和/同比/累计，保留公式；求值异常忽略）
            try {
                wb.getCreationHelper().createFormulaEvaluator().evaluateAll();
            } catch (Exception e) {
                log.warn("城市客运模板公式求值失败: {}", e.getMessage());
            }
            return toBytes(wb);
        }
    }

    /** æ¨¡æ¿æ–‡ä»¶å®šä½ï¼šé…ç½®ç›®å½• â†’ user.dir â†’ user.dir/.. é€çº§å›žé€€ */
    private File resolveTemplate(String fileName) throws Exception {
        return resolveAnyTemplate(templateDir, fileName);
    }

    /** å…¬è·¯æ—…客输出模板定位（docs/公路旅客+能耗/输出） */
    private File resolvePassengerTemplate(String fileName) throws Exception {
        return resolveAnyTemplate(passengerTemplateDir, fileName);
    }

    /** é€šç”¨æ¨¡æ¿æ–‡ä»¶å®šä½ï¼ˆç”¨äºŽåŸŽå¸‚客运/能耗等不同模板目录） */
    private File resolveAnyTemplate(String dir, String fileName) throws Exception {
        String rel = dir;
        while (rel.startsWith("./")) rel = rel.substring(2);
        String[] roots = {
            dir,
            System.getProperty("user.dir") + "/" + rel,
            System.getProperty("user.dir") + "/../" + rel
        };
        for (String root : roots) {
            if (root == null || root.trim().isEmpty()) continue;
            File f = new File(root, fileName);
            if (f.exists() && f.isFile()) return f;
        }
        throw new RuntimeException("未找到模板文件: " + fileName);
    }

    /** åŸŽå¸‚客运模板标题动态化：扫描全部文本单元格，替换写死的年份与累计区间（如 "2026å¹´1-6月" â†’ "2027å¹´1-8月"），列标题 "2026å¹´1月" åªæ¢å¹´ä»½ï¼›"1-12月" æ•´å¹´å¯¹æ¯”块（2024/2025）标题保持原样 */
    private void dynamicTitle(Sheet sheet, int year, int month) {
        java.util.regex.Pattern yearP = java.util.regex.Pattern.compile("\\d{4}å¹´");
        java.util.regex.Pattern rangeP = java.util.regex.Pattern.compile("(\\d+)-(\\d+)月");
        String cum = cumRange(month);
        for (int r = 0; r <= sheet.getLastRowNum(); r++) {
            Row row = sheet.getRow(r);
            if (row == null) continue;
            for (Cell cell : row) {
                if (cell.getCellType() != CellType.STRING) continue;
                String v = cell.getStringCellValue();
                if (v == null || v.isEmpty() || v.contains("1-12月")) continue; // æ•´å¹´å¯¹æ¯”块标题保持原样
                String nv = yearP.matcher(v).replaceAll(year + "å¹´");
                nv = rangeP.matcher(nv).replaceAll(java.util.regex.Matcher.quoteReplacement(cum));
                if (!nv.equals(v)) cell.setCellValue(nv);
            }
        }
    }

    /** åŸŽå¸‚客运分市州取值（月 â†’ å¸‚å·ž â†’ æŒ‡æ ‡æ•°ç»„） */
    private double cityVal(Map<Integer, Map<String, double[]>> monthCity, String area, int m, int idx) {
        Map<String, double[]> cityMap = monthCity.get(m);
        if (cityMap == null) return 0;
        double[] arr = cityMap.get(area);
        if (arr == null) return 0;
        return idx < arr.length ? arr[idx] : 0;
    }

    // ==================== æŠ•èµ„模块 4 å¼ é¢†å¯¼æŠ¥è¡¨ï¼ˆæ¨¡æ¿åº•ç¨¿ç”Ÿæˆï¼Œè¾“出 .xls） ====================

    /** åŠ è½½æŠ•èµ„ .xls æ¨¡æ¿ï¼ˆHSSFWorkbook，保留列宽/表头/样式/合并） */
    private HSSFWorkbook loadInvestTemplate(String fileName) throws Exception {
        File f = resolveAnyTemplate(investTemplateDir, fileName);
        try (InputStream in = new FileInputStream(f)) {
            return new HSSFWorkbook(in);
        }
    }

    /** æ¨¡æ¿å•å…ƒæ ¼å†™æ–‡æœ¬ï¼šå…ˆæ¸…空（保留样式/合并）再写，null/空白留空 */
    private void hssfText(Row row, int idx, String v) {
        Cell c = row.getCell(idx);
        if (c == null) c = row.createCell(idx);
        c.setBlank();
        if (v != null && !v.trim().isEmpty()) c.setCellValue(v.trim());
    }

    /** æ¨¡æ¿å•å…ƒæ ¼å†™æ•°å€¼ï¼šå…ˆæ¸…空（保留样式/合并）再写 */
    private void hssfNum(Row row, int idx, Double v) {
        Cell c = row.getCell(idx);
        if (c == null) c = row.createCell(idx);
        c.setBlank();
        if (v != null) c.setCellValue(v);
    }

    /** åˆ é™¤æ•°æ®åŒºå¤šä½™è¡Œï¼ˆfromRow..lastKeepRow-1）：先移除合并单元格再删行记录；表头合并不受影响 */
    private void trimHssfTail(HSSFSheet sheet, int fromRow, int lastKeepRow) {
        for (int i = sheet.getNumMergedRegions() - 1; i >= 0; i--) {
            CellRangeAddress m = sheet.getMergedRegion(i);
            if (m.getFirstRow() >= fromRow && m.getFirstRow() < lastKeepRow) {
                sheet.removeMergedRegion(i);
            }
        }
        for (int r = lastKeepRow - 1; r >= fromRow; r--) {
            HSSFRow row = sheet.getRow(r);
            if (row != null) sheet.removeRow(row);
        }
    }

    private void trimHssfTail(HSSFSheet sheet, int fromRow) {
        trimHssfTail(sheet, fromRow, sheet.getLastRowNum() + 1);
    }

    /** æ–°å»ºè¡Œå¹¶å¤åˆ¶æ¨¡æ¿è¡Œæ ·å¼ï¼ˆå«è¡Œé«˜ï¼‰ï¼Œä¿è¯ä¸Žæ¨¡æ¿æ•°æ®åŒºå¤–观一致 */
    private HSSFRow createRowLike(HSSFSheet sheet, int rowIdx, HSSFRow styleRow) {
        HSSFRow row = sheet.createRow(rowIdx);
        if (styleRow != null) {
            row.setHeight(styleRow.getHeight());
            for (int c = 0; c < styleRow.getLastCellNum(); c++) {
                HSSFCell sc = styleRow.getCell(c);
                if (sc == null) continue;
                row.createCell(c).setCellStyle(sc.getCellStyle());
            }
        }
        return row;
    }

    /** æ·»åŠ å•è¡Œåˆå¹¶å•å…ƒæ ¼ï¼ˆä¸Žæ¨¡æ¿æ•°æ®åŒºåˆå¹¶è§„则一致） */
    private void addMerge(HSSFSheet sheet, int r, int firstCol, int lastCol) {
        sheet.addMergedRegion(new CellRangeAddress(r, r, firstCol, lastCol));
    }

    /** è§£æž 4 ä½å¹´ä»½ä¸ºæ•°å€¼ï¼ˆå†™æ¨¡æ¿å¹´ä»½åˆ—），无法解析返回 null */
    private Double parseYearNum(String t) {
        if (t == null || t.trim().isEmpty()) return null;
        String s = t.trim().substring(0, Math.min(4, t.trim().length()));
        try {
            return Double.parseDouble(s);
        } catch (Exception e) {
            return null;
        }
    }

    /** è§£æž 6 ä½ YYYYMM ä¸ºæ•°å€¼ï¼ˆå†™æ¨¡æ¿å¼€å·¥æ—¶é—´åˆ—） */
    private Double parseTimeYMNum(String t) {
        if (t == null || t.trim().isEmpty()) return null;
        String x = padTimeYM(t.trim()).replaceAll("[^0-9]", "");
        if (x.length() < 6) return null;
        try {
            return Double.parseDouble(x.substring(0, 6));
        } catch (Exception e) {
            return null;
        }
    }

    private byte[] toBytesHssf(HSSFWorkbook wb) throws Exception {
        try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {
            wb.write(out);
            wb.close();
            return out.toByteArray();
        }
    }

    /** æŠ•èµ„模板 å¸‚州小节结构（表1/表2 åŠ¨æ€æ’行用） */
    private static class InvestSection {
        String blockCategory;
        String city;
        int startRow;
        int styleRowIdx = -1; // è¯¥å°èŠ‚首个项目行（复制样式用）
        List<Integer> projectRows = new ArrayList<>();
        Set<Long> matched = new HashSet<>();
    }

    /** åœ¨ pos è¡Œä¹‹åŽæ’å…¥ n è¡Œï¼šä¸‹æ–¹è¡Œä¸‹ç§»ï¼ˆåˆå¹¶åŒºå…ˆæ‘˜é™¤å†æŒ‰æ–°è¡Œå·æ¢å¤ï¼‰ï¼Œæ–°è¡Œå¤åˆ¶ styleRow æ ·å¼/行高/单行合并；返回首个新行索引 */
    private int insertRowsDown(HSSFSheet sheet, int pos, int n, HSSFRow styleRow) {
        if (n <= 0) return -1;
        List<CellRangeAddress> below = new ArrayList<>();
        for (int i = sheet.getNumMergedRegions() - 1; i >= 0; i--) {
            CellRangeAddress m = sheet.getMergedRegion(i);
            if (m.getFirstRow() > pos) {
                below.add(m);
                sheet.removeMergedRegion(i);
            }
        }
        int last = sheet.getLastRowNum();
        if (pos < last) {
            sheet.shiftRows(pos + 1, last, n, true, false);
        }
        for (CellRangeAddress m : below) {
            sheet.addMergedRegion(new CellRangeAddress(m.getFirstRow() + n, m.getLastRow() + n, m.getFirstColumn(), m.getLastColumn()));
        }
        int first = pos + 1;
        for (int i = 0; i < n; i++) {
            HSSFRow row = createRowLike(sheet, first + i, styleRow);
            if (styleRow != null) copyRowMerges(sheet, styleRow.getRowNum(), first + i);
        }
        return first;
    }

    /** å¤åˆ¶ styleRow æ‰€åœ¨è¡Œçš„单行合并区到 toRow（插入行外观与模板行一致） */
    private void copyRowMerges(HSSFSheet sheet, int fromRow, int toRow) {
        for (int i = 0; i < sheet.getNumMergedRegions(); i++) {
            CellRangeAddress m = sheet.getMergedRegion(i);
            if (m.getFirstRow() == fromRow && m.getLastRow() == fromRow) {
                sheet.addMergedRegion(new CellRangeAddress(toRow, toRow, m.getFirstColumn(), m.getLastColumn()));
            }
        }
    }

    /** æŠ•èµ„表 åºå·é‡æŽ’：表1 æŒ‰å—重置、表2 æŒ‰å¸‚州小节重置、表4 å…¨è¡¨è¿žç»­ï¼ˆæ¨¡æ¿/插入行统一排序） */
    private void renumberInvestSeq(HSSFSheet sheet, String kind) {
        int seq = 0;
        int lastRow = sheet.getLastRowNum();
        for (int r = 4; r <= lastRow; r++) {
            HSSFRow row = sheet.getRow(r);
            if (row == null) continue;
            String a = nvl(cellText(row.getCell(0)));
            if ("investPlan".equals(kind)) {
                if ("一、客运站场基础设施建设".equals(a) || "二、交通物流基础设施建设".equals(a) || "三、老旧营运货车报废更新".equals(a)) {
                    seq = 0;
                    continue;
                }
            } else if ("investFiveYear".equals(kind)) {
                if (isCityLabel(a)) {
                    seq = 0;
                    continue;
                }
            }
            String b = nvl(cellText(row.getCell(1)));
            if (b.isEmpty()) continue;
            hssfNum(row, 0, (double) (++seq));
        }
    }

    /** è¡¨1 é¡¹ç›®è¡Œå¡«å……（模板行/插入行共用；cityText ä¸Žæ¨¡æ¿ B åˆ—格式一致） */
    private void fillInvestPlanProjectRow(HSSFRow row, InvestmentProject p, InvestmentMonthly m, int seq, String cityText) {
        hssfNum(row, 0, (double) seq);
        hssfText(row, 1, cityText);
        hssfText(row, 2, valueOf(p.getCounty()));
        hssfText(row, 3, p.getProjectName());
        hssfText(row, 4, valueOf(p.getConstructNature()));
        hssfNum(row, 5, parseYearNum(p.getStartTime()));
        hssfNum(row, 6, parseYearNum(p.getEndTime()));
        hssfNum(row, 7, p.getTotalInvestment());
        hssfText(row, 20, p.getApprovalGk());
        hssfText(row, 21, p.getApprovalCs());
        if (m != null) {
            hssfNum(row, 8, m.getStartCum());
            hssfNum(row, 9, m.getYearPlan());
            hssfText(row, 13, m.getProgressDesc());
            hssfNum(row, 22, m.getYearCum());
            hssfText(row, 23, valueOf(m.getProgressStage()));
        }
    }

    /** è¡¨2 é¡¹ç›®è¡Œå¡«å……（模板行/插入行共用） */
    private void fillFiveYearProjectRow(HSSFRow row, InvestmentProject p, InvestmentMonthly m, int seq) {
        hssfNum(row, 0, (double) seq);
        hssfText(row, 1, p.getProjectName());
        hssfText(row, 2, valueOf(p.getBuilderName()));
        hssfNum(row, 3, parseYearNum(p.getStartTime()));
        hssfNum(row, 4, parseYearNum(p.getEndTime()));
        hssfNum(row, 5, p.getTotalInvestment());
        if (m != null) {
            hssfNum(row, 6, m.getStartCum());
            hssfNum(row, 7, m.getYearCum());
            hssfText(row, 8, valueOf(m.getProgressStage()));
            hssfText(row, 9, m.getProgressDesc());
        }
    }

    /** è¡¨4 é¡¹ç›®è¡Œå¡«å……（模板行/插入行共用） */
    private void fillCountyProjectRow(HSSFRow row, InvestmentProject p, InvestmentMonthly m, int seq) {
        hssfNum(row, 0, (double) seq);
        hssfText(row, 1, p.getProjectName());
        hssfText(row, 2, valueOf(p.getBuilderName()));
        hssfNum(row, 3, p.getTotalInvestment());
        if (m != null) {
            hssfNum(row, 4, m.getStartCum());
            hssfNum(row, 5, m.getYearPlan());
            hssfNum(row, 6, m.getYearCum());
            hssfNum(row, 7, m.getMonthDone());
            hssfText(row, 8, valueOf(m.getProgressStage()));
            hssfText(row, 9, m.getProgressDesc());
            if (m.getBuildingArea() != null && m.getBuildingArea() > 0) hssfNum(row, 12, m.getBuildingArea());
        }
        hssfText(row, 15, p.getApprovalGk());
        hssfText(row, 16, p.getApprovalCs());
    }

    /** è¡¨1：2026年全省预安排计划进度情况汇总（模板底稿原位替换：保留全部行/合并/列宽，仅替换数据；DB é¡¹ç›®å¤šäºŽæ¨¡æ¿é¢„留行时动态插行） */
    public byte[] investPlan(String period, String mode) throws Exception {
        int year = Integer.parseInt(period.split("-")[0]);
        int month = monthOf(period, mode);
        List<InvestmentMonthly> monthlies = investMonthlyMapper.selectList(
            new LambdaQueryWrapper<InvestmentMonthly>()
                .eq(InvestmentMonthly::getReportPeriod, period));
        Map<Long, InvestmentProject> pmap = new HashMap<>();
        List<InvestmentProject> projects = investProjectMapper.selectList(null);
        for (InvestmentProject p : projects) pmap.put(p.getId(), p);
        Map<Long, InvestmentMonthly> mByProject = new HashMap<>();
        for (InvestmentMonthly m : monthlies) mByProject.put(m.getProjectId(), m);

        HSSFWorkbook wb = loadInvestTemplate("模板_全省预安排计划进度情况汇总.xls");
        HSSFSheet sheet = wb.getSheetAt(0);
        // æ ‡é¢˜/表头年份与累计月份
        hssfText(sheet.getRow(1), 0, year + "年全省客货运站场建设预安排计划表");
        hssfText(sheet.getRow(2), 0, "蓝色项目为" + year + "年市州拟申报资金项目        å•ä½ï¼šä¸‡å…ƒ");
        hssfText(sheet.getRow(3), 22, cumRange(month) + "累计完成投资");
        // ç»“构扫描：块(客运/物流/老旧) -> å¸‚州小节 -> é¡¹ç›®è¡Œ
        List<InvestSection> sections = new ArrayList<>();
        String blockCategory = null;
        InvestSection cur = null;
        int firstProjectRow = -1;
        int lastRow = sheet.getLastRowNum();
        for (int r = 5; r <= lastRow; r++) {
            HSSFRow row = sheet.getRow(r);
            if (row == null) continue;
            String a = nvl(cellText(row.getCell(0)));
            String b = nvl(cellText(row.getCell(1)));
            String d = nvl(cellText(row.getCell(3)));
            if (r == 5) continue; // å…¨çœåˆè®¡è¡Œå•ç‹¬å¤„理
            if ("一、客运站场基础设施建设".equals(a) || "二、交通物流基础设施建设".equals(a) || "三、老旧营运货车报废更新".equals(a)) {
                blockCategory = a.startsWith("一、") ? "客运站场" : (a.startsWith("二、") ? "物流园区" : null);
                cur = null;
                continue;
            }
            if (a.startsWith("一、") || a.startsWith("二、")) continue; // é¢„安排计划内/外 åˆ†ç»„标题：归当前小节
            if (b.isEmpty() && d.isEmpty()) {
                cur = new InvestSection();
                cur.blockCategory = blockCategory;
                cur.city = templateCityFull(a);
                cur.startRow = r;
                sections.add(cur);
                continue;
            }
            if (cur != null) {
                cur.projectRows.add(r);
                if (cur.styleRowIdx < 0) cur.styleRowIdx = r;
                if (firstProjectRow < 0) firstProjectRow = r;
            }
        }
        HSSFRow globalStyle = firstProjectRow >= 0 ? sheet.getRow(firstProjectRow) : null;
        // åŽŸä½é€è¡Œæ›¿æ¢ï¼šåˆè®¡/块标题/市州小节/分组/项目行；未匹配的模板行清空样例数据（结构/合并/列宽不变）
        int seq = 0;
        int si = -1;
        for (int r = 5; r <= lastRow; r++) {
            HSSFRow row = sheet.getRow(r);
            if (row == null) continue;
            String a = nvl(cellText(row.getCell(0)));
            String b = nvl(cellText(row.getCell(1)));
            String d = nvl(cellText(row.getCell(3)));
            if (si + 1 < sections.size() && r >= sections.get(si + 1).startRow) si++;
            InvestSection sec = si >= 0 && si < sections.size() ? sections.get(si) : null;
            if (r == 5) { // å…¨çœåˆè®¡è¡Œ
                blankInvestRow(row, 25);
                hssfText(row, 0, "合计");
                InvestAgg prov = new InvestAgg();
                for (InvestmentMonthly m : monthlies) prov.add(m, pmap.get(m.getProjectId()));
                writeInvestAggHssf(row, prov);
                continue;
            }
            if ("一、客运站场基础设施建设".equals(a) || "二、交通物流基础设施建设".equals(a)) {
                blockCategory = a.startsWith("一、") ? "客运站场" : "物流园区";
                blankInvestRow(row, 25);
                hssfText(row, 0, a);
                InvestAgg agg = new InvestAgg();
                for (InvestmentMonthly m : monthlies) {
                    InvestmentProject p = pmap.get(m.getProjectId());
                    if (p != null && blockCategory.equals(p.getCategory())) agg.add(m, p);
                }
                writeInvestAggHssf(row, agg);
                seq = 0;
                continue;
            }
            if ("三、老旧营运货车报废更新".equals(a)) {
                blockCategory = null; // æš‚无数据源：整块清空
                blankInvestRow(row, 25);
                hssfText(row, 0, a);
                seq = 0;
                continue;
            }
            if (a.startsWith("一、") || a.startsWith("二、")) {
                // é¢„安排计划内/外 åˆ†ç»„标题行：无数据，仅保留标签
                blankInvestRow(row, 25);
                hssfText(row, 0, a);
                continue;
            }
            if (b.isEmpty() && d.isEmpty()) {
                // å¸‚州小节行：重算该市州（当前块类别）合计
                String city = templateCityFull(a);
                blankInvestRow(row, 25);
                hssfText(row, 0, a);
                InvestAgg agg = new InvestAgg();
                for (InvestmentMonthly m : monthlies) {
                    InvestmentProject p = pmap.get(m.getProjectId());
                    if (p != null && city.equals(p.getCity())
                        && (blockCategory == null || blockCategory.equals(p.getCategory()))) agg.add(m, p);
                }
                writeInvestAggHssf(row, agg);
                continue;
            }
            // é¡¹ç›®è¡Œï¼šæŒ‰ æ¨¡æ¿åç§°+市州+块类别 åŒ¹é… DB é¡¹ç›®ï¼ŒæœªåŒ¹é…æ•´è¡Œæ¸…空
            blankInvestRow(row, 25);
            if (blockCategory == null) continue; // è€æ—§è´§è½¦æ®µæ— æ•°æ®æº
            InvestmentProject p = matchInvest(projects, d, b, blockCategory);
            if (p == null) continue;
            if (sec != null) sec.matched.add(p.getId());
            InvestmentMonthly m = mByProject.get(p.getId());
            fillInvestPlanProjectRow(row, p, m, ++seq, b);
        }
        // åŠ¨æ€æ’行：DB é¡¹ç›®æ•° > æ¨¡æ¿é¢„留行数时，在市州小节末尾补齐（自底向上插行，避免行号错位）
        for (int i = sections.size() - 1; i >= 0; i--) {
            InvestSection s = sections.get(i);
            if (s.blockCategory == null || s.city == null) continue; // è€æ—§è´§è½¦æ®µæ— æ•°æ®æº
            List<InvestmentProject> extra = new ArrayList<>();
            for (InvestmentProject p : projects) {
                if (s.blockCategory.equals(p.getCategory())
                    && s.city.equals(RegionUtil.normalizeCityName(p.getCity()))
                    && !s.matched.contains(p.getId())) extra.add(p);
            }
            if (extra.isEmpty()) continue;
            HSSFRow styleRow = s.styleRowIdx >= 0 ? sheet.getRow(s.styleRowIdx) : globalStyle;
            int pos = s.projectRows.isEmpty() ? s.startRow : s.projectRows.get(s.projectRows.size() - 1);
            int first = insertRowsDown(sheet, pos, extra.size(), styleRow);
            for (int j = 0; j < extra.size(); j++) {
                HSSFRow row = sheet.getRow(first + j);
                if (row == null) continue;
                InvestmentProject p = extra.get(j);
                fillInvestPlanProjectRow(row, p, mByProject.get(p.getId()), 0, p.getCity());
            }
        }
        renumberInvestSeq(sheet, "investPlan");
        return toBytesHssf(wb);
    }

    /** å¸‚州小节/合计行数值：7总投资 8自开始累计 9本年计划 22自年初累计 23实际进度（部/省资金与自筹无数据源，留空） */
    private void writeInvestAggHssf(HSSFRow row, InvestAgg agg) {
        hssfNum(row, 7, agg.total == 0 ? null : agg.total);
        hssfNum(row, 8, agg.startCum == 0 ? null : agg.startCum);
        hssfNum(row, 9, agg.yearPlan == 0 ? null : agg.yearPlan);
        hssfNum(row, 22, agg.yearCum == 0 ? null : agg.yearCum);
        if (agg.yearPlan > 0) hssfNum(row, 23, round(agg.yearCum / agg.yearPlan, 4));
    }


    private static class InvestAgg {
        double total, startCum, yearPlan, yearCum;

        void add(InvestmentMonthly m, InvestmentProject p) {
            if (p != null) total += nz(p.getTotalInvestment());
            startCum += nz(m.getStartCum());
            yearPlan += nz(m.getYearPlan());
            yearCum += nz(m.getYearCum());
        }

        private double nz(Double v) {
            return v == null ? 0.0 : v;
        }
    }

    /** è¡¨2："十五五"规划物流项目进展情况（模板底稿原位替换：保留全部行/合并/列宽，仅替换数据；DB é¡¹ç›®å¤šäºŽæ¨¡æ¿é¢„留行时动态插行） */
    public byte[] investFiveYearLogistics(String period, String mode) throws Exception {
        List<InvestmentMonthly> monthlies = investMonthlyMapper.selectList(
            new LambdaQueryWrapper<InvestmentMonthly>()
                .eq(InvestmentMonthly::getReportPeriod, period));
        Map<Long, InvestmentProject> pmap = new HashMap<>();
        List<InvestmentProject> fiveProjects = new java.util.ArrayList<>();
        for (InvestmentProject p : investProjectMapper.selectList(null)) {
            pmap.put(p.getId(), p);
            if (Integer.valueOf(1).equals(p.getIsFiveYear())) fiveProjects.add(p);
        }
        Map<Long, InvestmentMonthly> mByProject = new HashMap<>();
        for (InvestmentMonthly m : monthlies) mByProject.put(m.getProjectId(), m);
        List<InvestmentMonthly> mine = new java.util.ArrayList<>();
        for (InvestmentMonthly m : monthlies) {
            InvestmentProject p = pmap.get(m.getProjectId());
            if (p != null && Integer.valueOf(1).equals(p.getIsFiveYear())) mine.add(m);
        }

        HSSFWorkbook wb = loadInvestTemplate("模板_十五五规划物流项目进展情况.xls");
        HSSFSheet sheet = wb.getSheetAt(1); // ã€Œ åˆ†é¡¹ç›®æŠ•èµ„完成情况」
        int lastRow = sheet.getLastRowNum();
        // ç»“构扫描：市州小节 -> é¡¹ç›®è¡Œ
        List<InvestSection> sections = new ArrayList<>();
        InvestSection cur = null;
        int firstProjectRow = -1;
        for (int r = 4; r <= lastRow; r++) {
            HSSFRow row = sheet.getRow(r);
            if (row == null) continue;
            String a = nvl(cellText(row.getCell(0)));
            String b = nvl(cellText(row.getCell(1)));
            if (r == 4) continue; // å…¨çœåˆè®¡è¡Œå•ç‹¬å¤„理
            if (b.isEmpty() && isCityLabel(a)) {
                cur = new InvestSection();
                cur.city = templateCityFull(a);
                cur.startRow = r;
                sections.add(cur);
                continue;
            }
            if (cur != null) {
                cur.projectRows.add(r);
                if (cur.styleRowIdx < 0) cur.styleRowIdx = r;
                if (firstProjectRow < 0) firstProjectRow = r;
            }
        }
        HSSFRow globalStyle = firstProjectRow >= 0 ? sheet.getRow(firstProjectRow) : null;
        String currentCity = null;
        int seq = 0;
        int si = -1;
        for (int r = 4; r <= lastRow; r++) {
            HSSFRow row = sheet.getRow(r);
            if (row == null) continue;
            String a = nvl(cellText(row.getCell(0)));
            String b = nvl(cellText(row.getCell(1)));
            if (si + 1 < sections.size() && r >= sections.get(si + 1).startRow) si++;
            InvestSection sec = si >= 0 && si < sections.size() ? sections.get(si) : null;
            if (r == 4) { // å…¨çœåˆè®¡è¡Œ
                blankInvestRow(row, 12);
                hssfText(row, 0, "合计");
                InvestAgg total = new InvestAgg();
                for (InvestmentMonthly m : mine) total.add(m, pmap.get(m.getProjectId()));
                hssfNum(row, 5, total.total == 0 ? null : total.total);
                hssfNum(row, 6, total.startCum == 0 ? null : total.startCum);
                hssfNum(row, 7, total.yearCum == 0 ? null : total.yearCum);
                continue;
            }
            if (b.isEmpty() && isCityLabel(a)) {
                currentCity = templateCityFull(a);
                seq = 0;
                blankInvestRow(row, 12);
                hssfText(row, 0, a);
                InvestAgg agg = new InvestAgg();
                for (InvestmentMonthly m : mine) {
                    InvestmentProject p = pmap.get(m.getProjectId());
                    if (p != null && currentCity.equals(p.getCity())) agg.add(m, p);
                }
                hssfNum(row, 5, agg.total == 0 ? null : agg.total);
                hssfNum(row, 6, agg.startCum == 0 ? null : agg.startCum);
                hssfNum(row, 7, agg.yearCum == 0 ? null : agg.yearCum);
                continue;
            }
            // é¡¹ç›®è¡Œï¼šæŒ‰ æ¨¡æ¿åç§°+市州 åŒ¹é… DB åäº”五项目，未匹配整行清空
            blankInvestRow(row, 12);
            InvestmentProject p = matchInvest(fiveProjects, b, currentCity, null);
            if (p == null) continue;
            if (sec != null) sec.matched.add(p.getId());
            InvestmentMonthly m = mByProject.get(p.getId());
            fillFiveYearProjectRow(row, p, m, ++seq);
        }
        // åŠ¨æ€æ’行：DB åäº”五项目数 > æ¨¡æ¿é¢„留行数时，在市州小节末尾补齐
        for (int i = sections.size() - 1; i >= 0; i--) {
            InvestSection s = sections.get(i);
            if (s.city == null) continue;
            List<InvestmentProject> extra = new ArrayList<>();
            for (InvestmentProject p : fiveProjects) {
                if (s.city.equals(RegionUtil.normalizeCityName(p.getCity()))
                    && !s.matched.contains(p.getId())) extra.add(p);
            }
            if (extra.isEmpty()) continue;
            HSSFRow styleRow = s.styleRowIdx >= 0 ? sheet.getRow(s.styleRowIdx) : globalStyle;
            int pos = s.projectRows.isEmpty() ? s.startRow : s.projectRows.get(s.projectRows.size() - 1);
            int first = insertRowsDown(sheet, pos, extra.size(), styleRow);
            for (int j = 0; j < extra.size(); j++) {
                HSSFRow row = sheet.getRow(first + j);
                if (row == null) continue;
                InvestmentProject p = extra.get(j);
                fillFiveYearProjectRow(row, p, mByProject.get(p.getId()), 0);
            }
        }
        renumberInvestSeq(sheet, "investFiveYear");
        return toBytesHssf(wb);
    }

    /** è¡¨4：（经济强县项目）湖北省交通物流基础设施投资统计报表（模板底稿原位替换：保留全部行/合并/列宽，仅替换数据；DB é¡¹ç›®å¤šäºŽæ¨¡æ¿é¢„留行时动态插行） */
    public byte[] investCounty(String period, String mode) throws Exception {
        List<InvestmentMonthly> monthlies = investMonthlyMapper.selectList(
            new LambdaQueryWrapper<InvestmentMonthly>()
                .eq(InvestmentMonthly::getReportPeriod, period));
        Map<Long, InvestmentProject> pmap = new HashMap<>();
        List<InvestmentProject> countyProjects = new java.util.ArrayList<>();
        for (InvestmentProject p : investProjectMapper.selectList(null)) {
            pmap.put(p.getId(), p);
            if (Integer.valueOf(1).equals(p.getIsCounty())) countyProjects.add(p);
        }
        Map<Long, InvestmentMonthly> mByProject = new HashMap<>();
        for (InvestmentMonthly m : monthlies) mByProject.put(m.getProjectId(), m);
        int year = Integer.parseInt(period.split("-")[0]);
        int month = monthOf(period, mode);

        HSSFWorkbook wb = loadInvestTemplate("模板_经济强县投资统计报表.xls");
        HSSFSheet sheet = wb.getSheetAt(0);
        hssfText(sheet.getRow(0), 0, "（经济强县项目）湖北省交通物流基础设施投资统计报表（" + month + "月月报）");
        hssfText(sheet.getRow(1), 0, "全省货运（物流）基础设施建设投资月报（" + year + "å¹´" + month + "月）");
        int lastRow = Math.min(sheet.getLastRowNum(), 65533);
        int seq = 0;
        int lastProjectRow = -1;
        Set<Long> matched = new HashSet<>();
        for (int r = 4; r <= lastRow; r++) {
            HSSFRow row = sheet.getRow(r);
            if (row == null) continue;
            String name = nvl(cellText(row.getCell(1)));
            if (name.isEmpty()) continue; // æ¨¡æ¿å°¾éƒ¨ç©ºè¡Œä¸å¤„理
            lastProjectRow = r;
            blankInvestRow(row, 20);
            InvestmentProject p = matchInvest(countyProjects, name, null, null);
            if (p == null) continue;
            matched.add(p.getId());
            InvestmentMonthly m = mByProject.get(p.getId());
            fillCountyProjectRow(row, p, m, ++seq);
        }
        // åŠ¨æ€æ’行：DB ç»æµŽå¼ºåŽ¿é¡¹ç›®æ•° > æ¨¡æ¿é¢„留行数时，在项目区末尾补齐
        List<InvestmentProject> extra = new ArrayList<>();
        for (InvestmentProject p : countyProjects) {
            if (!matched.contains(p.getId())) extra.add(p);
        }
        if (!extra.isEmpty()) {
            HSSFRow styleRow = sheet.getRow(4);
            int pos = lastProjectRow >= 4 ? lastProjectRow : 3;
            int first = insertRowsDown(sheet, pos, extra.size(), styleRow);
            for (int j = 0; j < extra.size(); j++) {
                HSSFRow row = sheet.getRow(first + j);
                if (row == null) continue;
                InvestmentProject p = extra.get(j);
                fillCountyProjectRow(row, p, mByProject.get(p.getId()), 0);
            }
        }
        renumberInvestSeq(sheet, "investCounty");
        return toBytesHssf(wb);
    }


    /** è¡¨3：湖北省（客货站场）亿元投资项目（模板底稿 .xls，投资总表 + è§„上项目表 ä¸¤ sheet） */
    public byte[] investBillion(String period, String mode) throws Exception {
        List<InvestmentMonthly> monthlies = investMonthlyMapper.selectList(
            new LambdaQueryWrapper<InvestmentMonthly>()
                .eq(InvestmentMonthly::getReportPeriod, period));
        Map<Long, InvestmentProject> pmap = new HashMap<>();
        for (InvestmentProject p : investProjectMapper.selectList(null)) pmap.put(p.getId(), p);
        List<InvestmentMonthly> mine = new java.util.ArrayList<>();
        for (InvestmentMonthly m : monthlies) {
            InvestmentProject p = pmap.get(m.getProjectId());
            if (p != null && Integer.valueOf(1).equals(p.getIsBillion())) mine.add(m);
        }
        int year = Integer.parseInt(period.split("-")[0]);
        int month = monthOf(period, mode);

        HSSFWorkbook wb = loadInvestTemplate("模板_亿元投资项目.xls");
        // ---- sheet1 æŠ•èµ„总表：固定骨架，仅填（五）其他 å…¨å¹´é¢„计（全省本年计划折亿） ----
        HSSFSheet s1 = wb.getSheetAt(0);
        hssfText(s1.getRow(0), 0, year + "年固定资产投资预计完成情况");
        double provinceYearPlan = 0;
        for (InvestmentMonthly m : monthlies) provinceYearPlan += nz(m.getYearPlan());
        HSSFRow rowOther = s1.getRow(9);
        for (int c = 1; c <= 5; c++) hssfNum(rowOther, c, null);
        hssfNum(rowOther, 5, provinceYearPlan == 0 ? null : round(provinceYearPlan / 10000, 2));
        // ---- sheet2 è§„上项目表：表头年份 + åˆè®¡ + é¡¹ç›®è¡Œ ----
        HSSFSheet s2 = wb.getSheetAt(1);
        hssfText(s2.getRow(0), 0, year + "年交通建设项目储备情况（规模以上项目）");
        hssfText(s2.getRow(2), 5, "截止到" + year + "å¹´" + month + "月底建设状态");
        hssfText(s2.getRow(2), 9, "截至" + (year - 1) + "年年底实际完成投资（万元）");
        hssfText(s2.getRow(2), 10, year + "å¹´1-3月实际完成投资（万元）");
        hssfText(s2.getRow(2), 11, year + "å¹´4月计划完成投资（万元）");
        hssfText(s2.getRow(2), 12, year + "年第二季度计划完成投资（万元）");
        hssfText(s2.getRow(2), 13, year + "年全年计划完成投资（万元）");
        hssfText(s2.getRow(2), 16, year + "å¹´1-4月计划完成投资（万元）");
        hssfText(s2.getRow(2), 17, year + "å¹´4月实际完成投资（万元）");
        hssfText(s2.getRow(2), 18, year + "å¹´1-4月累计完成投资（万元）");
        hssfText(s2.getRow(2), 19, year + "å¹´5月实际完成投资（万元）");
        hssfText(s2.getRow(2), 21, year + "å¹´6月实际完成投资（万元）");
        hssfText(s2.getRow(2), 22, year + "年第二季度实际完成投资（万元）");
        hssfText(s2.getRow(2), 23, year + "å¹´" + month + "月实际完成投资");
        // åˆè®¡è¡Œ R4（col0-1 å±žäºŽè¡¨å¤´åˆå¹¶åŒºï¼Œä¿ç•™ï¼›æ¸…空并重写数据列）
        HSSFRow totalRow = s2.getRow(4);
        for (int c = 2; c <= 23; c++) hssfNum(totalRow, c, null);
        InvestAgg total = new InvestAgg();
        for (InvestmentMonthly m : mine) total.add(m, pmap.get(m.getProjectId()));
        hssfNum(totalRow, 8, total.total == 0 ? null : total.total);
        hssfNum(totalRow, 13, total.yearPlan == 0 ? null : total.yearPlan);
        hssfNum(totalRow, 23, sumMonth(mine) == 0 ? null : sumMonth(mine));
        // é¡¹ç›®è¡Œï¼šä¿ç•™æ¨¡æ¿ R79 æ³¨é‡Šè¡Œ
        HSSFRow styleProject = s2.getRow(5);
        trimHssfTail(s2, 5, 79);
        int rowIdx = 5;
        for (InvestmentMonthly m : mine) {
            InvestmentProject p = pmap.get(m.getProjectId());
            HSSFRow row = createRowLike(s2, rowIdx++, styleProject);
            hssfText(row, 0, "湖北省");
            hssfText(row, 1, RegionUtil.shortName(p.getCity()));
            hssfText(row, 2, p.getProjectName());
            hssfText(row, 3, "客运站场".equals(p.getCategory()) ? "综合客运枢纽" : "综合货运枢纽");
            hssfText(row, 5, valueOf(m.getProgressStage()));
            hssfText(row, 6, valueOf(p.getConstructNature()));
            hssfNum(row, 7, parseTimeYMNum(p.getStartTime()));
            hssfNum(row, 8, p.getTotalInvestment());
            hssfNum(row, 13, m.getYearPlan());
            hssfNum(row, 23, m.getMonthDone());
        }
        trimHssfTail(s2, rowIdx, 79);
        return toBytesHssf(wb);
    }

    /** ç©ºä¸²å½’一（cellText å¯èƒ½è¿”回 null） */
    private String nvl(String v) {
        return v == null ? "" : v.trim();
    }

    /** æ¸…空模板数据行指定范围单元格（保留样式与合并单元格） */
    private void blankInvestRow(HSSFRow row, int lastCol) {
        if (row == null) return;
        for (int c = 0; c <= lastCol; c++) {
            Cell cell = row.getCell(c);
            if (cell != null) cell.setBlank();
        }
    }

    /** æ¨¡æ¿å¸‚州短名 -> è§„范市州名（武汉->武汉市、林区->神农架林区、恩施州->恩施州） */
    private String templateCityFull(String label) {
        if (label == null) return null;
        String t = label.trim();
        String canon = RegionUtil.normalizeCityName(t);
        for (String city : RegionUtil.cityList()) {
            if (city.equals(canon)) return city;
        }
        for (String city : RegionUtil.cityList()) {
            if (RegionUtil.shortName(city).equals(canon) || RegionUtil.shortName(city).equals(t)) return city;
        }
        return canon;
    }

    /** åˆ¤æ–­æ¨¡æ¿è¡Œ A åˆ—是否为市州小节标签 */
    private boolean isCityLabel(String label) {
        if (label == null || label.isEmpty()) return false;
        String full = templateCityFull(label);
        return full != null && RegionUtil.cityList().contains(full);
    }

    /** åœ¨å€™é€‰é¡¹ç›®æ± ä¸­æŒ‰åç§°åŒ¹é… DB é¡¹ç›®ï¼ˆå¯é€‰ å¸‚å·ž/类别 è¿‡æ»¤ + åŽ¿åŒºå‰ç¼€æ¶ˆæ­§ï¼‰ï¼Œæœªå‘½ä¸­è¿”回 null */
    private InvestmentProject matchInvest(List<InvestmentProject> pool, String name, String cityFull, String category) {
        if (name == null || name.trim().isEmpty()) return null;
        String norm = normInvestName(name);
        if (norm.isEmpty()) return null;
        String cityCanon = cityFull == null || cityFull.trim().isEmpty() ? null : RegionUtil.normalizeCityName(cityFull);
        String county = extractInvestCounty(name);
        List<InvestmentProject> cands = new java.util.ArrayList<>();
        for (InvestmentProject p : pool) {
            if (category != null && !category.equals(p.getCategory())) continue;
            if (cityCanon != null && !cityCanon.equals(RegionUtil.normalizeCityName(p.getCity()))) continue;
            cands.add(p);
        }
        if (cands.isEmpty()) return null;
        // å½’一化同名多候选：县区前缀消歧（如 ç½—田县综合物流园 vs å’¸ä¸°åŽ¿ç»¼åˆç‰©æµå›­ï¼‰
        if (!county.isEmpty()) {
            for (InvestmentProject p : cands) {
                if (normInvestName(p.getProjectName()).equals(norm)
                    && p.getProjectName() != null && p.getProjectName().contains(county)) {
                    return p;
                }
            }
        }
        InvestmentProject best = null;
        int bestScore = Integer.MIN_VALUE;
        for (InvestmentProject p : cands) {
            String pn = normInvestName(p.getProjectName());
            if (pn.isEmpty()) continue;
            int s = investNameScore(norm, pn, county, p.getProjectName());
            if (s > bestScore) {
                bestScore = s;
                best = p;
            }
        }
        return bestScore > 0 ? best : null;
    }

    /** é¡¹ç›®åå½’一化：去括号字符、连接符，罗马数字统一，去省/市/县/区前缀与空白（与审核引擎一致） */
    private String normInvestName(String name) {
        if (name == null) return "";
        String s = name.trim();
        s = s.replaceAll("[（(]", "").replaceAll("[）)]", "");
        s = s.replaceAll("[·•—－_\\-]", "");
        s = s.replaceAll("[ⅠⅡⅢⅣⅤⅥⅦⅧⅨⅩⅰⅱⅲⅳⅴⅵⅶⅷⅸⅹ]", "I");
        s = s.replaceAll("^(湖北省|武汉市|黄石市|十堰市|宜昌市|襄阳市|鄂州市|荆门市|孝感市|荆州市|黄冈市|咸宁市|随州市|恩施州|仙桃市|潜江市|天门市|神农架林区)", "");
        s = s.replaceAll("^(?:[\\u4e00-\\u9fa5]{2,4}(?:县|市|区))", "");
        s = s.replaceAll("\\s+", "");
        return s;
    }

    /** åç§°ç›¸ä¼¼åº¦è¯„分：精确>前缀包含>中后部包含>5字>子序列>最长公共子串；县区前缀不一致拒绝/大扣分 */
    private int investNameScore(String norm, String key, String county, String rawB) {
        if (norm.equals(key)) {
            // å½’一化后同名：若模板带县区前缀而候选原始名不含该县区 â†’ æ‹’绝（防 å®œéƒ½å¸‚ vs å½“阳市 è¯¯é…ï¼‰
            if (county != null && !county.isEmpty() && (rawB == null || !rawB.contains(county))) return -1;
            return 2000;
        }
        if (key.length() < 5 || norm.length() < 5) return -1;
        String shortSide = key.length() <= norm.length() ? key : norm;
        String longSide = key.length() > norm.length() ? key : norm;
        int idx = longSide.indexOf(shortSide);
        int lenDiff = Math.abs(key.length() - norm.length());
        int base;
        if (idx == 0) {
            base = 1000 - lenDiff * 2;
        } else if (idx > 0 && shortSide.length() >= 6) {
            base = 500 - idx * 5 - lenDiff * 2 + shortSide.length();
        } else if (idx > 0 && shortSide.length() == 5 && lenDiff <= 5) {
            String diff = longSide.substring(0, idx) + longSide.substring(idx + shortSide.length());
            if (diff.matches(".*(县|市|州).*")) return -1;
            base = 400 - idx * 5 - lenDiff;
        } else if (isInvestSubsequence(shortSide, longSide) && lenDiff <= 8) {
            base = 300 - lenDiff * 3;
        } else {
            int l = investLcs(norm, key);
            if (l >= 6) {
                base = 200 + l * 5 - lenDiff;
            } else if (l == 5 && lenDiff <= 4 && county != null && !county.isEmpty()
                       && rawB != null && rawB.contains(county)) {
                base = 150 + l * 5 - lenDiff;
            } else {
                return -1;
            }
        }
        if (county != null && !county.isEmpty() && (rawB == null || !rawB.contains(county))) {
            base -= 400;
        }
        return base;
    }

    /** åˆ¤æ–­çŸ­åæ˜¯å¦ä¸ºé•¿åçš„字符子序列 */
    private boolean isInvestSubsequence(String shortSide, String longSide) {
        int i = 0;
        for (int j = 0; i < shortSide.length() && j < longSide.length(); j++) {
            if (shortSide.charAt(i) == longSide.charAt(j)) i++;
        }
        return i == shortSide.length();
    }

    /** æœ€é•¿å…¬å…±å­ä¸²é•¿åº¦ */
    private int investLcs(String a, String b) {
        int n = a.length(), m = b.length();
        if (n == 0 || m == 0) return 0;
        int[][] dp = new int[n + 1][m + 1];
        int max = 0;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                if (a.charAt(i - 1) == b.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                    if (dp[i][j] > max) max = dp[i][j];
                }
            }
        }
        return max;
    }

    /** æå–名称中的 åŽ¿/市/区 å‰ç¼€ï¼ˆå¦‚ å’¸ä¸°åŽ¿ã€å®œéƒ½å¸‚） */
    private String extractInvestCounty(String name) {
        if (name == null) return "";
        java.util.regex.Matcher mm = java.util.regex.Pattern.compile("([\\u4e00-\\u9fa5]{2,4}(?:县|市|区))").matcher(name);
        if (mm.find()) return mm.group(1);
        return "";
    }


    private double sumMonth(List<InvestmentMonthly> list) {
        double s = 0;
        for (InvestmentMonthly m : list) s += nz(m.getMonthDone());
        return s;
    }

    private String padTimeYM(String t) {
        if (t == null) return null;
        String x = t.trim();
        if (x.matches("\\d{4}")) return x + "01";
        return x;
    }

    private String valueOf(String v) {
        return v == null || v.trim().isEmpty() ? "" : v.trim();
    }
    private double nz(Double v) {
        return v == null ? 0.0 : v;
    }
    private byte[] toBytes(XSSFWorkbook wb) throws Exception {
        try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {
            wb.write(out);

 traffic-audit-server/src/main/java/com/trafficaudit/rulemanage/controller/RuleManageController.java

New file
@@ -0,0 +1,57 @@
package com.trafficaudit.rulemanage.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.trafficaudit.common.Result;
import com.trafficaudit.rulemanage.entity.AuditRule;
import com.trafficaudit.rulemanage.mapper.AuditRuleMapper;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.List;

/** è§„则管理：按报表类型查看/启停/调整阈值 */
@RestController
@RequestMapping("/api/rules")
public class RuleManageController {

    @Resource
    private AuditRuleMapper ruleMapper;

    /** è§„则列表，可按报表类型过滤 */
    @GetMapping("/list")
    public Result<List<AuditRule>> list(@RequestParam(value = "reportType", required = false) String reportType) {
        LambdaQueryWrapper<AuditRule> qw = new LambdaQueryWrapper<>();
        if (reportType != null && !reportType.trim().isEmpty()) {
            qw.eq(AuditRule::getReportType, reportType.trim());
        }
        qw.orderByAsc(AuditRule::getSortOrder);
        return Result.ok(ruleMapper.selectList(qw));
    }

    /** å¯åœè§„则 */
    @PostMapping("/toggle")
    public Result<String> toggle(@RequestParam("id") Long id,
                                 @RequestParam("enabled") Integer enabled) {
        AuditRule rule = ruleMapper.selectById(id);
        if (rule == null) return Result.error("规则不存在");
        rule.setIsEnabled(enabled == null || enabled == 0 ? 0 : 1);
        rule.setUpdatedAt(LocalDateTime.now());
        ruleMapper.updateById(rule);
        return Result.ok("已更新");
    }

    /** æ›´æ–°é˜ˆå€¼/等级/描述 */
    @PostMapping("/update")
    public Result<String> update(@RequestBody AuditRule body) {
        if (body.getId() == null) return Result.error("缺少规则ID");
        AuditRule rule = ruleMapper.selectById(body.getId());
        if (rule == null) return Result.error("规则不存在");
        if (body.getThreshold() != null) rule.setThreshold(body.getThreshold());
        if (body.getAlertLevel() != null) rule.setAlertLevel(body.getAlertLevel());
        if (body.getDescription() != null) rule.setDescription(body.getDescription());
        rule.setUpdatedAt(LocalDateTime.now());
        ruleMapper.updateById(rule);
        return Result.ok("已保存");
    }
}

 traffic-audit-server/src/main/java/com/trafficaudit/security/controller/LoginController.java

@@ -1,8 +1,12 @@
package com.trafficaudit.security.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.trafficaudit.common.Result;
import com.trafficaudit.security.captcha.CaptchaService;
import com.trafficaudit.security.utils.JwtUtils;
import com.trafficaudit.system.entity.User;
import com.trafficaudit.system.mapper.UserMapper;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
@@ -20,6 +24,12 @@

    @Resource
    private CaptchaService captchaService;

    @Resource
    private UserMapper userMapper;

    @Resource
    private PasswordEncoder passwordEncoder;

    @PostMapping("/login")
    public Result<Map<String, Object>> login(@RequestBody Map<String, Object> params) {
@@ -39,14 +49,32 @@
            return Result.error(4001, "行为验证未通过，请重新验证");
        }

        if ("admin".equals(username) && "admin123".equals(password)) {
            String token = jwtUtils.generateToken(username);
        if (username == null || username.trim().isEmpty() || password == null || password.isEmpty()) {
            return Result.error(401, "用户名或密码错误");
        }
        User user = userMapper.selectOne(new LambdaQueryWrapper<User>()
                .eq(User::getUsername, username.trim()));
        if (user == null || !Integer.valueOf(1).equals(user.getStatus())) {
            return Result.error(401, "用户名或密码错误");
        }
        String encoded = user.getPassword();
        boolean ok;
        try {
            ok = encoded != null && passwordEncoder.matches(password, encoded);
        } catch (IllegalArgumentException e) {
            // åº“中密码不是合法 BCrypt æ—¶å›žé€€ä¸ºæ˜Žæ–‡å¯¹æ¯”（避免旧数据无法登录）
            ok = encoded != null && encoded.equals(password);
        }
        if (!ok) {
            return Result.error(401, "用户名或密码错误");
        }
        String token = jwtUtils.generateToken(username.trim());
            Map<String, Object> data = new HashMap<>();
            data.put("token", token);
            data.put("username", username);
        data.put("username", username.trim());
        data.put("realName", user.getRealName());
        data.put("modules", user.getModules() == null ? "" : user.getModules());
            return Result.ok(data);
        }
        return Result.error(401, "用户名或密码错误");
    }

    @SuppressWarnings("unchecked")

 traffic-audit-server/src/main/java/com/trafficaudit/system/controller/UserController.java

New file
@@ -0,0 +1,107 @@
package com.trafficaudit.system.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.trafficaudit.common.Result;
import com.trafficaudit.system.entity.User;
import com.trafficaudit.system.mapper.UserMapper;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/** ç”¨æˆ·ç®¡ç†ï¼ˆå«è´Ÿè´£æŠ¥è¡¨æ¨¡å—配置：freight/passenger/invest/energy/cityPassenger） */
@RestController
@RequestMapping("/api/user")
public class UserController {

    @Resource
    private UserMapper userMapper;
    @Resource
    private PasswordEncoder passwordEncoder;

    @GetMapping("/list")
    public Result<List<Map<String, Object>>> list(@RequestParam(value = "keyword", required = false) String keyword) {
        LambdaQueryWrapper<User> qw = new LambdaQueryWrapper<>();
        if (keyword != null && !keyword.trim().isEmpty()) {
            String k = keyword.trim();
            qw.and(w -> w.like(User::getUsername, k).or().like(User::getRealName, k));
        }
        qw.orderByAsc(User::getId);
        List<Map<String, Object>> data = new ArrayList<>();
        for (User u : userMapper.selectList(qw)) {
            Map<String, Object> m = new HashMap<>();
            m.put("id", u.getId());
            m.put("username", u.getUsername());
            m.put("realName", u.getRealName());
            m.put("phone", u.getPhone());
            m.put("status", u.getStatus());
            m.put("modules", u.getModules());
            m.put("createdAt", u.getCreatedAt() == null ? null : u.getCreatedAt().toString());
            data.add(m);
        }
        return Result.ok(data);
    }

    /** æ–°å¢ž/编辑用户；编辑时 password ç•™ç©ºåˆ™ä¸ä¿®æ”¹å¯†ç ï¼›modules ä¸ºæ¨¡å— key æ•°ç»„ */
    @PostMapping("/save")
    public Result<Void> save(@RequestBody Map<String, Object> params) {
        Object idObj = params.get("id");
        Long id = idObj == null ? null : Long.valueOf(idObj.toString());
        String username = str(params.get("username"));
        if (username == null || username.trim().isEmpty()) return Result.error(400, "用户名不能为空");
        username = username.trim();
        String password = str(params.get("password"));
        String realName = str(params.get("realName"));
        String phone = str(params.get("phone"));
        Integer status = params.get("status") == null ? 1 : Integer.valueOf(params.get("status").toString());
        List<String> moduleKeys = new ArrayList<>();
        Object modulesObj = params.get("modules");
        if (modulesObj instanceof List) {
            for (Object o : (List<?>) modulesObj) if (o != null) moduleKeys.add(o.toString());
        }
        String modules = String.join(",", moduleKeys);

        LambdaQueryWrapper<User> dup = new LambdaQueryWrapper<User>().eq(User::getUsername, username);
        if (id != null) dup.ne(User::getId, id);
        if (userMapper.selectCount(dup) != null && userMapper.selectCount(dup) > 0) return Result.error(400, "用户名已存在");

        if (id == null) {
            if (password == null || password.isEmpty()) return Result.error(400, "新增用户必须设置密码");
            User u = new User();
            u.setUsername(username);
            u.setRealName(realName);
            u.setPhone(phone);
            u.setStatus(status);
            u.setModules(modules);
            u.setPassword(passwordEncoder.encode(password));
            userMapper.insert(u);
        } else {
            User u = userMapper.selectById(id);
            if (u == null) return Result.error(404, "用户不存在");
            u.setRealName(realName);
            u.setPhone(phone);
            u.setStatus(status);
            u.setModules(modules);
            if (password != null && !password.isEmpty()) u.setPassword(passwordEncoder.encode(password));
            userMapper.updateById(u);
        }
        return Result.ok(null);
    }

    @PostMapping("/delete")
    public Result<Void> delete(@RequestParam("id") Long id) {
        User u = userMapper.selectById(id);
        if (u == null) return Result.error(404, "用户不存在");
        if ("admin".equals(u.getUsername())) return Result.error(400, "admin ä¸å…è®¸åˆ é™¤");
        userMapper.deleteById(id);
        return Result.ok(null);
    }

    private String str(Object o) {
        return o == null ? null : o.toString();
    }
}

 traffic-audit-server/src/main/java/com/trafficaudit/system/entity/OperationLog.java

New file
@@ -0,0 +1,22 @@
package com.trafficaudit.system.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.util.Date;

/** æ“ä½œæ—¥å¿—（sys_operation_log）：报表生成/导入等关键操作留痕 */
@Data
@TableName("sys_operation_log")
public class OperationLog {
    @TableId(type = IdType.AUTO)
    private Long id;
    private Long userId;
    private String module;
    private String action;
    private String detail;
    private String ipAddress;
    private Date createdAt;
}

 traffic-audit-server/src/main/java/com/trafficaudit/system/entity/User.java

@@ -17,4 +17,6 @@
    private String phone;
    private Long deptId;
    private Integer status;
    /** è´Ÿè´£æŠ¥è¡¨æ¨¡å—，逗号分隔：freight,passenger,invest,energy,cityPassenger */
    private String modules;
}

 traffic-audit-server/src/main/java/com/trafficaudit/system/mapper/OperationLogMapper.java

New file
@@ -0,0 +1,8 @@
package com.trafficaudit.system.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.trafficaudit.system.entity.OperationLog;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface OperationLogMapper extends BaseMapper<OperationLog> {}

 traffic-audit-server/src/main/java/com/trafficaudit/system/service/OperationLogService.java

New file
@@ -0,0 +1,75 @@
package com.trafficaudit.system.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.trafficaudit.security.utils.JwtUtils;
import com.trafficaudit.system.entity.OperationLog;
import com.trafficaudit.system.entity.User;
import com.trafficaudit.system.mapper.OperationLogMapper;
import com.trafficaudit.system.mapper.UserMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;

/**
 * æ“ä½œæ—¥å¿—服务：记录关键操作（报表生成/系列打包等），自动从 Authorization å¤´è§£æžå½“前用户。
 * è§£æžå¤±è´¥æˆ–未登录时不抛异常，仅记录操作本身。
 */
@Slf4j
@Service
public class OperationLogService {

    @Resource
    private OperationLogMapper operationLogMapper;
    @Resource
    private UserMapper userMapper;
    @Resource
    private JwtUtils jwtUtils;
    @Resource
    private HttpServletRequest request;

    public void record(String module, String action, String detail) {
        try {
            OperationLog entry = new OperationLog();
            entry.setModule(module);
            entry.setAction(action);
            entry.setDetail(detail);
            entry.setUserId(resolveUserId());
            entry.setIpAddress(clientIp());
            operationLogMapper.insert(entry);
        } catch (Exception e) {
            log.warn("操作日志记录失败: {}", e.getMessage());
        }
    }

    private Long resolveUserId() {
        try {
            String auth = request.getHeader("Authorization");
            if (auth == null || !auth.startsWith("Bearer ")) {
                return null;
            }
            String username = jwtUtils.getUsernameFromToken(auth.substring(7));
            if (username == null || username.isEmpty()) {
                return null;
            }
            User user = userMapper.selectOne(new LambdaQueryWrapper<User>()
                .eq(User::getUsername, username).last("limit 1"));
            return user == null ? null : user.getId();
        } catch (Exception e) {
            return null;
        }
    }

    private String clientIp() {
        try {
            String ip = request.getHeader("X-Forwarded-For");
            if (ip != null && !ip.isEmpty()) {
                return ip.split(",")[0].trim();
            }
            return request.getRemoteAddr();
        } catch (Exception e) {
            return "";
        }
    }
}

 traffic-audit-server/src/main/resources/application.yml.example

@@ -4,10 +4,14 @@

spring:
  datasource:
    url: jdbc:mysql://localhost:3305/traffic_audit?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai&useSSL=false
    url: jdbc:mysql://localhost:3305/traffic_audit?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai&useSSL=false&allowPublicKeyRetrieval=true&rewriteBatchedStatements=true
    username: root
    password: ${MYSQL_PASSWORD:root}
    driver-class-name: com.mysql.cj.jdbc.Driver
  servlet:
    multipart:
      max-file-size: 100MB
      max-request-size: 100MB
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: Asia/Shanghai
@@ -29,6 +33,24 @@
  secret: ${JWT_SECRET:change-me-jwt-secret}
  expiration: 86400000

docs:
  template-root: docs

city-passenger:
  template-dir: docs/城市客运

passenger:
  template-dir: docs/公路旅客

freight:
  template-dir: docs/货运

energy:
  template-dir: docs/能耗

investment:
  template-dir: docs/投资/模板

deepseek:
  api-key: ${DEEPSEEK_API_KEY:your-deepseek-api-key}
  api-url: https://api.deepseek.com/v1/chat/completions

 traffic-audit-web/src/App.vue

@@ -1,6 +1,8 @@
<template>
  <div id="app">
    <keep-alive include="AuditResult">
    <router-view />
    </keep-alive>
  </div>
</template>
<script>

 traffic-audit-web/src/main.js

@@ -7,6 +7,19 @@
Vue.use(ElementUI)
Vue.config.productionTip = false

// å…¨å±€ç™»å‡ºï¼šæ¸…除登录态并回登录页（各页面侧边栏「退出登录」菜单共用）
Vue.mixin({
  methods: {
    logout() {
      localStorage.removeItem('token')
      localStorage.removeItem('username')
      localStorage.removeItem('realName')
      localStorage.removeItem('modules')
      this.$router.push('/login')
    }
  }
})

new Vue({
  router,
  render: h => h(App)

 traffic-audit-web/src/views/AuditResult.vue

@@ -14,54 +14,210 @@
          <el-menu-item index="/users">用户管理</el-menu-item>
        </el-menu>
      </el-aside>
      <el-main>
        <h3>审核结果</h3>
        <el-form :inline="true">
      <el-main :class="{ 'main-focus': focusMode }" style="display:flex;flex-direction:column;min-height:0">
        <h3 v-show="!focusMode" style="flex:none;margin:0 0 10px">审核结果</h3>
        <el-form :inline="true" style="flex:none">
          <el-form-item label="报表类型">
            <el-radio-group v-model="reportType" @change="onTypeChange">
              <el-radio label="H2032">货运月报</el-radio>
              <el-radio label="H2031">旅客月报</el-radio>
              <el-radio label="CITY_BUS">城市公交月报</el-radio>
              <el-radio label="CITY_TAXI">巡游出租月报</el-radio>
              <el-radio label="INVEST">投资月报</el-radio>
              <el-radio label="H204">能耗季报</el-radio>
            
            
            
            </el-radio-group>
          </el-form-item>
          <el-form-item label="报表期">
            <el-date-picker v-model="period" type="month" placeholder="选择月份" value-format="yyyy-MM"></el-date-picker>
            <el-date-picker v-model="period" type="month" placeholder="选择月份" value-format="yyyy-MM" @change="onPeriodChange"></el-date-picker>
          </el-form-item>
          <el-form-item>
            <el-button type="primary" @click="executeAudit" :loading="loading">执行审核</el-button>
            <el-button type="success" plain @click="markAudited" :loading="marking">标记已审核</el-button>
            <el-button @click="queryResults">查询结果</el-button>
            <el-button type="success" icon="el-icon-download" @click="exportExcel">导出 Excel</el-button>
            <el-button v-if="!focusMode" size="small" icon="el-icon-full-screen" @click="focusMode = true">聚焦查看</el-button>
            <el-button v-else type="primary" size="small" icon="el-icon-crop" @click="focusMode = false">退出聚焦</el-button>
          </el-form-item>
        </el-form>
        <el-form :inline="true" style="margin-top:12px">
        <!-- é—®é¢˜æ¦‚览统计卡 -->
        <div v-if="results.length && !focusMode" class="sev-cards" style="flex:none">
          <div class="sev-card sev-red"><b>{{ severityStats.red }}</b> çº¢è‰²é—®é¢˜</div>
          <div class="sev-card sev-yellow"><b>{{ severityStats.yellow }}</b> é»„色问题</div>
          <div class="sev-card sev-pending"><b>{{ severityStats.pending }}</b> å¾…处理</div>
          <div class="sev-card sev-done"><b>{{ severityStats.done }}</b> å·²å¤„理</div>
        </div>
        <el-form v-if="!focusMode" :inline="true" style="margin-top:8px;flex:none">
          <el-form-item label="企业名称">
            <el-input v-model="enterpriseFilter" placeholder="输入企业名称关键字" clearable style="width:220px"></el-input>
            <el-input v-model="enterpriseFilter" placeholder="输入企业名称关键字" clearable style="width:200px" @keyup.enter.native="queryResults"></el-input>
          </el-form-item>
          <el-form-item label="审核规则">
            <el-select v-model="ruleFilter" placeholder="全部规则" clearable style="width:200px">
            <el-select v-model="ruleFilter" placeholder="全部规则" clearable style="width:180px">
              <el-option v-for="rn in ruleOptions" :key="rn" :label="rn" :value="rn"></el-option>
            </el-select>
          </el-form-item>
          <el-form-item label="视图">
            <el-radio-group v-model="viewMode">
              <el-radio label="detail">按条明细</el-radio>
              <el-radio label="merged">按企业合并</el-radio>
            </el-radio-group>
          </el-form-item>
          <el-form-item v-if="viewMode === 'detail'">
            <el-button size="small" type="success" :disabled="!batchPending.length" @click="reviewBatch('CONFIRMED')">批量确认({{ batchPending.length }})</el-button>
            <el-button size="small" type="info" :disabled="!batchPending.length" @click="reviewBatch('IGNORED')">批量忽略({{ batchPending.length }})</el-button>
          </el-form-item>
          <el-form-item>
            <el-button size="small" @click="clearFilters">清空过滤</el-button>
            <el-button size="small" plain @click="statsCollapsed = !statsCollapsed">{{ statsCollapsed ? '展开' : '收起' }}规则统计</el-button>
          </el-form-item>
          <el-form-item>
            <span style="color:#909399;font-size:12px">共 {{ results.length }} æ¡ï¼Œå½“前显示 {{ filteredResults.length }} æ¡</span>
            <span style="color:#909399;font-size:12px">共 {{ results.length }} æ¡é—®é¢˜ï¼Œ{{ mergedResults.length }} å®¶ä¼ä¸š</span>
          </el-form-item>
        </el-form>
        <div class="table-area">
        <el-table :data="filteredResults" border v-loading="loading" height="100%">
          <el-table-column prop="enterpriseName" label="企业名称" min-width="200" show-overflow-tooltip></el-table-column>
          <el-table-column prop="ruleName" label="审核规则" min-width="140"></el-table-column>
          <el-table-column prop="actualValue" label="实际值" min-width="180" show-overflow-tooltip></el-table-column>
          <el-table-column prop="thresholdValue" label="阈值/对比" min-width="120"></el-table-column>
          <el-table-column prop="deviation" label="偏差说明" min-width="140" show-overflow-tooltip></el-table-column>
          <el-table-column label="等级" width="80">
        <div v-if="ruleStats.length && !statsCollapsed && !focusMode" class="rule-stats" style="flex:none">
          <div class="stats-cards">
            <div v-for="rs in sortedRuleStats" :key="rs.ruleId" class="stat-card"
                 :class="{ 'has-hit': rs.hit > 0, 'is-skipped': rs.skipped, active: ruleFilter === rs.ruleName }"
                 :title="rs.ruleName + '（' + rs.ruleCode + '）检查' + rs.checked + ' å‘½ä¸­' + rs.hit + '（点击过滤）'"
                 @click="toggleRuleFilter(rs)">
              <template v-if="rs.skipped">
                <span class="stat-name">{{ rs.ruleName }}</span>
                <span class="skip-label">基准缺失，已跳过</span>
              </template>
              <template v-else>
                <span class="stat-name">{{ rs.ruleName }}</span>
                <span class="stat-num"><b :class="{ 'hit-num': rs.hit > 0 }">{{ rs.hit }}</b> / {{ rs.checked }}</span>
              </template>
            </div>
          </div>
        </div>
        <div v-if="focusMode" style="flex:none;padding:0 2px 6px;color:#909399;font-size:12px">
          å…± {{ results.length }} æ¡é—®é¢˜ï¼Œ{{ mergedResults.length }} å®¶ä¼ä¸š
        </div>
        <div class="table-area" style="flex:1;min-height:0">
        <!-- æ˜Žç»†è§†å›¾ï¼šä¸€æ¡é—®é¢˜ä¸€å¼ å¡ç‰‡ -->
        <div v-if="viewMode === 'detail'" class="detail-cards-wrap" v-loading="loading">
          <div class="detail-toolbar">
            <el-checkbox :value="allSelected" :indeterminate="someSelected" @change="toggleSelectAll">全选当前 {{ filteredResults.length }} æ¡</el-checkbox>
            <span class="toolbar-tip">勾选后可批量确认 / å¿½ç•¥</span>
          </div>
          <div v-for="row in filteredResults" :key="row.id" class="detail-card"
               :class="{ 'card-red': row.alertLevel === 'RED', 'card-yellow': row.alertLevel === 'YELLOW', 'card-done': row.status !== 'PENDING' }">
            <div class="card-head">
              <el-checkbox v-model="row._selected" @change="updateBatchSelection"></el-checkbox>
              <div class="card-ent">
                <div class="ent-name">{{ row.enterpriseName || row.city || '未知企业' }}</div>
                <div class="ent-sub">{{ row.reportPeriod }}</div>
              </div>
              <el-tag :type="row.alertLevel === 'RED' ? 'danger' : 'warning'" size="small" effect="dark">{{ row.alertLevel }}</el-tag>
              <el-tag :type="statusType(row.status)" size="small" effect="plain" class="status-tag">
                <i :class="statusIcon(row.status)"></i> {{ statusText(row.status) }}
              </el-tag>
              <span class="spacer"></span>
              <el-link v-if="dataType(reportType)" type="primary" :underline="false" size="mini" @click="goData(row)">数据</el-link>
              <el-tag v-if="explainType(reportType)" size="mini" :type="row.verifyExplanation ? 'success' : 'warning'"
                       style="cursor:pointer" :title="expandedExplain === row.reportId ? '收起解释' : '展开填写/查看解释'"
                       @click="toggleExplain(row.reportId)">
                {{ row.verifyExplanation ? '解释：已填写' : '解释：未填写' }}
              </el-tag>
              <el-button v-if="row.status === 'PENDING'" size="mini" type="success" icon="el-icon-check" round @click="review(row, 'CONFIRMED')">确认</el-button>
              <el-button v-if="row.status === 'PENDING'" size="mini" type="info" icon="el-icon-close" round plain @click="review(row, 'IGNORED')">忽略</el-button>
              <span v-else class="done-text">已处理</span>
            </div>
            <div class="card-body">
              <div class="rule-title">
                <b>{{ row.ruleName }}</b>
                <span class="rule-code">{{ row.ruleCode }}</span>
              </div>
              <div class="card-details">
                <div class="detail-line"><span class="dt-label">实际</span><span class="dt-val">{{ row.actualValue }}</span></div>
                <div class="detail-line"><span class="dt-label">基准</span><span class="dt-val">{{ row.thresholdValue }}</span></div>
                <div class="detail-line"><span class="dt-label">差异</span><span class="dt-val dt-warn">{{ row.deviation }}</span></div>
              </div>
            </div>
            <div v-if="explainType(reportType) && expandedExplain === row.reportId" class="explain-side" style="margin:0 12px 10px">
              <div class="explain-head">
                <span class="explain-title">企业解释</span>
                <el-tag size="mini" :type="row.verifyExplanation ? 'success' : 'warning'">{{ row.verifyExplanation ? '已填写' : '未填写' }}</el-tag>
                <span style="flex:1"></span>
                <el-button size="mini" text @click="expandedExplain = null">收起</el-button>
              </div>
              <span v-if="row.verifyExplanation" class="explain-cur">{{ row.verifyExplanation }}</span>
              <el-input v-model="explainDrafts[row.reportId]" type="textarea" :rows="2" resize="none"
                        placeholder="填写/修改该企业的解释说明…"></el-input>
              <div class="explain-actions">
                <el-button size="mini" type="primary" plain :loading="savingExplainId === row.reportId" @click="saveExplain(row)">保存解释</el-button>
                <el-button v-if="(explainDrafts[row.reportId] || '') !== (row.verifyExplanation || '')" size="mini" text @click="resetDraft(row.reportId)">重置</el-button>
              </div>
            </div>
          </div>
          <div v-if="!filteredResults.length" class="empty-tip">
            <el-empty description="当前筛选条件下没有问题数据"></el-empty>
          </div>
        </div>
        <!-- åˆå¹¶è§†å›¾ -->
        <el-table v-else :data="mergedResults" border stripe v-loading="loading" height="100%"
          :header-cell-style="{ background: '#F5F7FA', color: '#303133', fontWeight: 600 }">
          <el-table-column label="企业" min-width="190">
            <template slot-scope="scope">
              <el-tag :type="scope.row.alertLevel === 'RED' ? 'danger' : 'warning'">{{ scope.row.alertLevel }}</el-tag>
              <div style="font-weight:600">{{ scope.row.enterpriseName }}</div>
              <div style="color:#909399;font-size:12px;margin-top:2px">共 {{ scope.row.items.length }} æ¡é—®é¢˜</div>
            </template>
          </el-table-column>
          <el-table-column prop="status" label="状态" width="100">
          <el-table-column label="审核问题明细" min-width="520">
            <template slot-scope="scope">
              <el-tag :type="statusType(scope.row.status)">{{ scope.row.status }}</el-tag>
              <div v-for="(item, i) in scope.row.items" :key="item.id"
                   style="padding:6px 0;border-bottom:1px dashed #EBEEF5"
                   :class="{ 'no-border': i === scope.row.items.length - 1 }">
                <div style="display:flex;align-items:center;flex-wrap:wrap;gap:6px">
                  <b>{{ item.ruleName }}</b>
                  <el-tag :type="item.alertLevel === 'RED' ? 'danger' : 'warning'" size="mini">{{ item.alertLevel }}</el-tag>
                  <el-tag :type="statusType(item.status)" size="mini">{{ statusText(item.status) }}</el-tag>
                  <el-link v-if="dataType(reportType)" type="primary" :underline="false" size="mini" @click="goData(item)">数据</el-link>
                  <span style="flex:1"></span>
                  <el-button v-if="item.status === 'PENDING'" size="mini" type="success" @click="review(item, 'CONFIRMED')">确认</el-button>
                  <el-button v-if="item.status === 'PENDING'" size="mini" type="info" @click="review(item, 'IGNORED')">忽略</el-button>
                </div>
                <div style="color:#606266;font-size:12px;line-height:1.6;margin-top:2px">
                  <span>实际：{{ item.actualValue }}</span>
                  <span style="margin:0 8px">基准：{{ item.thresholdValue }}</span>
                  <span>差异：{{ item.deviation }}</span>
                </div>
              </div>
            </template>
          </el-table-column>
          <el-table-column label="操作" width="160">
          <el-table-column label="企业解释" width="340">
            <template slot-scope="scope">
              <el-button v-if="scope.row.status === 'PENDING'" size="mini" type="success" @click="review(scope.row, 'CONFIRMED')">确认</el-button>
              <el-button v-if="scope.row.status === 'PENDING'" size="mini" type="info" @click="review(scope.row, 'IGNORED')">忽略</el-button>
              <div v-if="explainType(reportType) && scope.row.items[0]" class="explain-cell">
                <div v-if="expandedExplain !== scope.row.items[0].reportId" class="explain-compact">
                  <el-tag size="mini" :type="scope.row.items[0].verifyExplanation ? 'success' : 'warning'">{{ scope.row.items[0].verifyExplanation ? '已填写' : '未填写' }}</el-tag>
                  <div v-if="scope.row.items[0].verifyExplanation" class="explain-preview">{{ scope.row.items[0].verifyExplanation }}</div>
                  <el-button size="mini" text type="primary" @click="expandedExplain = scope.row.items[0].reportId">填写/修改</el-button>
                </div>
                <div v-else class="explain-side">
                  <div class="explain-head">
                    <span class="explain-title">企业解释</span>
                    <span style="flex:1"></span>
                    <el-button size="mini" text @click="expandedExplain = null">收起</el-button>
                  </div>
                  <span v-if="scope.row.items[0].verifyExplanation" class="explain-cur">{{ scope.row.items[0].verifyExplanation }}</span>
                  <el-input v-model="explainDrafts[scope.row.items[0].reportId]" type="textarea" :rows="2" resize="none"
                            placeholder="填写/修改该企业的解释说明…"></el-input>
                  <div class="explain-actions">
                    <el-button size="mini" type="primary" plain :loading="savingExplainId === scope.row.items[0].reportId" @click="saveExplain(scope.row.items[0])">保存解释</el-button>
                    <el-button v-if="(explainDrafts[scope.row.items[0].reportId] || '') !== (scope.row.items[0].verifyExplanation || '')" size="mini" text @click="resetDraft(scope.row.items[0].reportId)">重置</el-button>
                  </div>
                </div>
              </div>
              <span v-else style="color:#C0C4CC;font-size:12px">—</span>
            </template>
          </el-table-column>
          <el-table-column label="操作" width="130">
            <template slot-scope="scope">
              <el-button v-if="hasPending(scope.row)" size="mini" type="success" plain @click="reviewAll(scope.row, 'CONFIRMED')">全部确认</el-button>
              <el-button v-if="hasPending(scope.row)" size="mini" type="info" plain @click="reviewAll(scope.row, 'IGNORED')">全部忽略</el-button>
            </template>
          </el-table-column>
        </el-table>
@@ -73,12 +229,16 @@
<script>
import AppHeader from '@/components/AppHeader.vue'
import api from '@/api'
const DATA_TYPE_MAP = { H2032: 'h2032', H2031: 'h2031', CITY_BUS: 'cityBus', CITY_TAXI: 'cityTaxi' }
const EXPLAIN_TYPES = ['H2032', 'H2031', 'CITY_BUS', 'CITY_TAXI']
export default {
  components: { AppHeader },
  name: 'AuditResult',
  data() {
    return {
      period: '', loading: false, results: [], enterpriseFilter: '', ruleFilter: ''
      period: '', reportType: 'H2032', loading: false, marking: false, results: [], ruleStats: [], statsCollapsed: false,
      enterpriseFilter: '', ruleFilter: '', viewMode: 'merged', batchSelection: [], focusMode: false,
      explainDrafts: {}, savingExplainId: null, expandedExplain: null
    }
  },
  computed: {
@@ -86,6 +246,25 @@
      const names = []
      this.results.forEach(r => { if (r.ruleName && names.indexOf(r.ruleName) < 0) names.push(r.ruleName) })
      return names
    },
    severityStats() {
      const s = { red: 0, yellow: 0, pending: 0, done: 0 }
      this.results.forEach(r => {
        if (r.alertLevel === 'RED') s.red++
        else if (r.alertLevel === 'YELLOW') s.yellow++
        if (r.status === 'PENDING') s.pending++
        else s.done++
      })
      return s
    },
    batchPending() { return this.batchSelection.filter(x => x.status === 'PENDING') },
    allSelected() {
      const list = this.filteredResults
      return list.length > 0 && list.every(r => r._selected)
    },
    someSelected() {
      const list = this.filteredResults
      return list.some(r => r._selected) && !this.allSelected
    },
    filteredResults() {
      const kw = (this.enterpriseFilter || '').trim()
@@ -96,48 +275,310 @@
        if (rule && r.ruleName !== rule) return false
        return true
      })
    },
    sortedRuleStats() {
      const arr = (this.ruleStats || []).slice()
      arr.sort((a, b) => {
        const ah = a.hit > 0 ? 1 : 0
        const bh = b.hit > 0 ? 1 : 0
        if (ah !== bh) return bh - ah
        return (a.ruleId || 0) - (b.ruleId || 0)
      })
      return arr
    },
    mergedResults() {
      const map = new Map()
      this.filteredResults.forEach(r => {
        const key = r.enterpriseName || r.actualValue || '未知企业'
        if (!map.has(key)) map.set(key, [])
        map.get(key).push(r)
      })
      return Array.from(map.entries())
        .map(([name, items]) => ({ enterpriseName: name, items }))
        .sort((a, b) => b.items.length - a.items.length)
    }
  },
  methods: {
    dataType(t) { return DATA_TYPE_MAP[t] || '' },
    explainType(t) { return EXPLAIN_TYPES.indexOf(t) >= 0 },
    goData(row) {
      const type = DATA_TYPE_MAP[this.reportType]
      if (!type) return
      this.$router.push({ path: '/data', query: { type, period: row.reportPeriod, keyword: row.enterpriseName || row.city || '' } })
    },
    goExplain(row) {
      this.$router.push({ path: '/explain', query: { reportType: this.reportType, keyword: row.enterpriseName || row.city || '', period: row.reportPeriod } })
    },
    onTypeChange() {
      this.ruleFilter = ''; this.batchSelection = []; this.results = []; this.ruleStats = []
      this.period = ''
      this.loadLatestPeriod(true)
    },
    onPeriodChange() {
      if (this.period) this.queryResults(); else { this.results = []; this.ruleStats = [] }
    },
    loadLatestPeriod(autoQuery) {
      api.get('/audit/latestPeriod', { params: { reportType: this.reportType } })
        .then(res => {
          const p = res.data
          if (p && !this.period) {
            this.period = p
            if (autoQuery) this.queryResults()
          } else if (autoQuery && !p) {
            this.results = []; this.ruleStats = []
          }
        })
        .catch(() => {})
    },
    executeAudit() {
      if (!this.period) { this.$message.warning('请选择报表期'); return }
      this.loading = true
      const fd = new FormData()
      fd.append('period', this.period)
      fd.append('reportType', this.reportType)
      api.post('/audit/execute', fd)
        .then(res => {
          const count = (res.data || []).length
          return api.get('/audit/ruleStats', { params: { period: this.period, reportType: this.reportType } })
            .then(stats => {
              const list = stats.data || []
              const checked = list.reduce((s, r) => Math.max(s, Number(r.checked) || 0), 0)
              if (list.length === 0) {
                this.$message.warning('该报表类型没有启用审核规则，未执行审核')
              } else if (checked === 0) {
                this.$message.warning('该报表期没有数据，未执行审核（请先导入数据）')
              } else {
                const skipped = list.filter(x => x.skipped)
                if (skipped.length > 0) {
                  const names = skipped.map(x => x.ruleCode).join('、')
                  this.$message.warning('审核完成，共 ' + count + ' æ¡é—®é¢˜ï¼›' + names + ' å› åŸºå‡†æ•°æ®ï¼ˆè¿æ”¿/轨迹/上月等）缺失已跳过')
                } else {
          this.$message.success('审核完成，共 ' + count + ' æ¡é—®é¢˜')
          return api.get('/audit/results', { params: { period: this.period } })
                }
              }
        })
        .then(res => { this.results = res.data || [] })
        })
        .then(() => api.get('/audit/results', { params: { period: this.period, reportType: this.reportType } }))
        .then(res => { this.applyResults(res.data) })
        .then(() => this.loadRuleStats())
        .catch(() => { this.$message.error('审核执行失败') })
        .finally(() => { this.loading = false })
    },
    markAudited() {
      if (!this.period) { this.$message.warning('请选择报表期'); return }
      this.marking = true
      const fd = new FormData()
      fd.append('period', this.period)
      fd.append('reportType', this.reportType)
      api.post('/audit/markAudited', fd)
        .then(res => {
          if (res.data) {
            this.$message.success('已标记该期「' + this.reportType + '」为已审核，报表导出不再提示未审核')
          } else {
            this.$message.warning('该类型没有启用规则或该期没有数据，未写入标记')
          }
          return api.get('/audit/results', { params: { period: this.period, reportType: this.reportType } })
        })
        .then(res => { this.applyResults(res.data) })
        .catch(() => { this.$message.error('标记失败') })
        .finally(() => { this.marking = false })
    },
    queryResults() {
      if (!this.period) { this.$message.warning('请选择报表期'); return }
      this.loading = true
      api.get('/audit/results', { params: { period: this.period } })
        .then(res => { this.results = res.data || [] })
      api.get('/audit/results', { params: { period: this.period, reportType: this.reportType } })
        .then(res => { this.applyResults(res.data) })
        .then(() => this.loadRuleStats())
        .catch(() => { this.$message.error('查询失败') })
        .finally(() => { this.loading = false })
    },
    toggleExplain(reportId) {
      this.expandedExplain = this.expandedExplain === reportId ? null : reportId
    },
    applyResults(list) {
      this.results = (list || []).map(r => Object.assign({}, r, { _selected: false }))
      this.results.forEach(r => {
        if (r.reportId && this.explainDrafts[r.reportId] === undefined) {
          this.$set(this.explainDrafts, r.reportId, r.verifyExplanation || '')
        }
      })
    },
    saveExplain(row) {
      const reportId = row.reportId
      if (!reportId) { this.$message.warning('无法定位该企业的数据行'); return }
      const explanation = (this.explainDrafts[reportId] || '').trim()
      this.savingExplainId = reportId
      const fd = new FormData()
      fd.append('reportType', this.reportType)
      fd.append('reportId', reportId)
      fd.append('explanation', explanation)
      api.post('/explain/save', fd)
        .then(() => {
          this.$message.success('企业解释已保存')
          this.$set(this.explainDrafts, reportId, explanation)
          this.results.forEach(r => { if (r.reportId === reportId) r.verifyExplanation = explanation })
        })
        .catch(e => { this.$message.error((e.response && e.response.data && e.response.data.message) || '保存失败') })
        .finally(() => { this.savingExplainId = null })
    },
    resetDraft(reportId) {
      const row = this.results.find(r => r.reportId === reportId)
      if (row) this.$set(this.explainDrafts, reportId, row.verifyExplanation || '')
    },
    loadRuleStats() {
      if (!this.period) return
      api.get('/audit/ruleStats', { params: { period: this.period, reportType: this.reportType } })
        .then(res => { this.ruleStats = res.data || [] })
        .catch(() => { this.ruleStats = [] })
    },
    exportExcel() {
      if (!this.period) { this.$message.warning('请选择报表期'); return }
      window.open('/api/audit/export?period=' + this.period + '&reportType=' + this.reportType)
    },
    review(row, status) {
      if (status === 'IGNORED') {
        this.$prompt('请输入忽略原因（方便事后追溯）', '忽略问题', {
          inputPlaceholder: '原因（可选）', inputType: 'textarea', confirmButtonText: '确定忽略', cancelButtonText: '取消'
        }).then(({ value }) => this.doReview(row, status, (value || '').trim()))
          .catch(() => {})
      } else {
        this.doReview(row, status)
      }
    },
    doReview(row, status, comment) {
      const fd = new FormData()
      fd.append('id', row.id)
      fd.append('status', status)
      if (comment) fd.append('comment', comment)
      api.post('/audit/review', fd)
        .then(() => { row.status = status; this.$message.success('已处理') })
        .then(() => { row.status = status; this.$message.success(status === 'CONFIRMED' ? '已确认' : '已忽略') })
        .catch(() => { this.$message.error('操作失败') })
    },
    updateBatchSelection() { this.batchSelection = this.filteredResults.filter(r => r._selected) },
    toggleSelectAll(value) {
      this.filteredResults.forEach(r => { r._selected = value })
      this.updateBatchSelection()
    },
    reviewBatch(status) {
      const list = this.batchPending.slice()
      if (list.length === 0) return
      if (status === 'IGNORED') {
        this.$prompt('请输入忽略原因（应用于选中的 ' + list.length + ' æ¡ï¼‰', '批量忽略', {
          inputPlaceholder: '原因（可选）', inputType: 'textarea', confirmButtonText: '确定忽略', cancelButtonText: '取消'
        }).then(({ value }) => this.doReviewBatch(list, status, (value || '').trim()))
          .catch(() => {})
      } else {
        this.doReviewBatch(list, status)
      }
    },
    doReviewBatch(list, status, comment) {
      let done = 0
      list.forEach(item => {
        const fd = new FormData()
        fd.append('id', item.id)
        fd.append('status', status)
        if (comment) fd.append('comment', comment)
        api.post('/audit/review', fd)
          .then(() => { item.status = status; done++; if (done === list.length) this.$message.success('å·²' + (status === 'CONFIRMED' ? '确认' : '忽略') + ' ' + done + ' æ¡') })
          .catch(() => { this.$message.error('部分操作失败') })
      })
    },
    clearFilters() { this.enterpriseFilter = ''; this.ruleFilter = '' },
    toggleRuleFilter(rs) {
      this.ruleFilter = this.ruleFilter === rs.ruleName ? '' : rs.ruleName
    },
    hasPending(group) { return group.items.some(x => x.status === 'PENDING') },
    reviewAll(group, status) {
      const pending = group.items.filter(x => x.status === 'PENDING')
      if (pending.length === 0) return
      if (status === 'IGNORED') {
        this.$prompt('请输入忽略原因（应用于该企业 ' + pending.length + ' æ¡é—®é¢˜ï¼‰', '忽略', {
          inputPlaceholder: '原因（可选）', inputType: 'textarea', confirmButtonText: '确定忽略', cancelButtonText: '取消'
        }).then(({ value }) => this.doReviewBatch(pending, status, (value || '').trim()))
          .catch(() => {})
      } else {
        this.doReviewBatch(pending, status)
      }
    },
    statusType(status) {
      if (status === 'CONFIRMED') return 'success'
      if (status === 'IGNORED') return 'info'
      return 'warning'
    },
    statusText(status) {
      if (status === 'CONFIRMED') return '已确认'
      if (status === 'IGNORED') return '已忽略'
      return '待处理'
    },
    statusIcon(status) {
      if (status === 'CONFIRMED') return 'el-icon-circle-check'
      if (status === 'IGNORED') return 'el-icon-circle-close'
      return 'el-icon-time'
    }
  },
  mounted() {
    this.loadLatestPeriod(true)
  }
}
</script>
<style scoped>
.el-header { background: #409EFF; color: white; line-height: 60px; font-size: 18px; }
.no-border { border-bottom: none !important; }
.sev-cards { display: flex; gap: 10px; }
.sev-card { flex: 1; max-width: 180px; border-radius: 6px; padding: 6px 12px; font-size: 13px; color: #606266; }
.sev-card b { font-size: 20px; margin-right: 4px; }
.sev-red { background: #FEF0F0; border: 1px solid #FDE2E2; }
.sev-red b { color: #F56C6C; }
.sev-yellow { background: #FDF6EC; border: 1px solid #FAECD8; }
.sev-yellow b { color: #E6A23C; }
.sev-pending { background: #F4F4F5; border: 1px solid #E9E9EB; }
.sev-pending b { color: #606266; }
.sev-done { background: #F0F9EB; border: 1px solid #E1F3D8; }
.sev-done b { color: #67C23A; }
.ent-name { font-weight: 600; color: #303133; }
.ent-sub { color: #909399; font-size: 12px; margin-top: 2px; }
.rule-name { font-weight: 500; color: #303133; }
.rule-code { color: #909399; font-size: 12px; margin-top: 2px; }
.detail-line { display: flex; align-items: baseline; line-height: 1.7; }
.dt-label { flex: none; width: 34px; color: #909399; font-size: 12px; }
.dt-val { flex: 1; color: #606266; word-break: break-all; }
.dt-warn { color: #E6A23C; }
.status-tag i { margin-right: 3px; }
.done-text { color: #C0C4CC; font-size: 12px; }
.explain-side { background: #FAFAFA; border: 1px solid #EBEEF5; border-radius: 6px; padding: 8px 10px; }
.explain-cell { min-height: 40px; }
.explain-compact .explain-preview { color: #909399; font-size: 12px; line-height: 1.5; margin: 4px 0; max-height: 40px; overflow: hidden; display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical; word-break: break-all; }
.explain-head { display: flex; align-items: center; gap: 8px; margin-bottom: 6px; }
.explain-title { font-weight: 600; color: #303133; font-size: 13px; }
.explain-cur { display: block; color: #909399; font-size: 12px; white-space: pre-wrap; word-break: break-all; line-height: 1.5; margin-bottom: 6px; }
.explain-actions { margin-top: 6px; }
.main-focus { padding: 8px 12px !important; }
.detail-cards-wrap { flex: 1; min-height: 0; overflow-y: auto; padding: 2px 4px 16px; }
.detail-toolbar { display: flex; align-items: center; gap: 10px; padding: 0 2px 8px; }
.toolbar-tip { color: #909399; font-size: 12px; }
.detail-card { background: #FFF; border: 1px solid #EBEEF5; border-left: 3px solid #E6A23C; border-radius: 6px; margin-bottom: 10px; box-shadow: 0 1px 2px rgba(0,0,0,.04); }
.detail-card.card-red { border-left-color: #F56C6C; }
.detail-card.card-yellow { border-left-color: #E6A23C; }
.detail-card.card-done { opacity: .72; background: #FAFAFA; }
.card-head { display: flex; align-items: center; gap: 8px; padding: 10px 12px 4px; }
.card-ent { flex: 1; min-width: 0; }
.spacer { flex: 1; }
.card-body { padding: 2px 12px 10px; }
.rule-title { display: flex; align-items: baseline; gap: 8px; margin: 2px 0 4px; }
.rule-title b { font-size: 14px; color: #303133; }
.card-details { display: flex; flex-wrap: wrap; gap: 4px 24px; background: #F8F9FB; border: 1px solid #F0F2F5; border-radius: 4px; padding: 6px 10px; }
.card-details .detail-line { display: flex; align-items: baseline; line-height: 1.8; min-width: 200px; }
.empty-tip { padding: 30px 0; }
.rule-stats { margin: 0 0 8px; }
.stats-cards { display: flex; overflow-x: auto; gap: 6px; padding: 4px 0; }
.stat-card { flex: none; display: inline-flex; align-items: center; gap: 6px; border: 1px solid #EBEEF5; border-radius: 14px; padding: 3px 10px; background: #FAFAFA; font-size: 12px; white-space: nowrap; cursor: pointer; }
.stat-card:hover { border-color: #C0C4CC; }
.stat-card.has-hit { background: #FDF6EC; border-color: #E6A23C; }
.stat-card.is-skipped { background: #F2F6FC; border-color: #DCDFE6; opacity: 0.85; }
.stat-card.active { border-color: #409EFF; box-shadow: 0 0 0 1px #409EFF; }
.skip-label { color: #909399; font-size: 12px; }
.stat-name { color: #606266; max-width: 150px; overflow: hidden; text-overflow: ellipsis; }
.stat-num { color: #909399; }
.stat-num b { font-weight: 700; }
.hit-num { color: #E6A23C; }
</style>

 traffic-audit-web/src/views/Dashboard.vue

@@ -11,8 +11,7 @@
          <el-menu-item index="/audit">审核结果</el-menu-item>
          <el-menu-item index="/report">报表生成</el-menu-item>
          <el-menu-item index="/rules">规则管理</el-menu-item>
          <el-menu-item index="/users">用户管理</el-menu-item>
        </el-menu>
          <el-menu-item index="/users">用户管理</el-menu-item></el-menu>
      </el-aside>
      <el-main>
        <div class="page-scroll">
@@ -26,9 +25,9 @@
          <el-card style="margin-top:20px">
            <div slot="header">Demo æ•°æ®æµ</div>
            <ol>
              <li>数据导入：H203-2月报 / è¿æ”¿è½¦è¾† / è½¨è¿¹é‡Œç¨‹ / è§„上规下拆分（支持重复导入覆盖）</li>
              <li>审核引擎：6条预置规则（车辆/吨位运政对比、周转量轨迹对比、货运类型环比、集装箱异常、整车吨位范围）</li>
              <li>报表生成：货运量周转量、分市州明细、货运量排名、周转量排名（点击生成并下载）</li>
              <li>数据导入：H203-2货运月报 / H203-1旅客月报（含运政）/ è¿æ”¿è½¦è¾† / è½¨è¿¹é‡Œç¨‹ / è§„上规下拆分（支持重复导入覆盖）</li>
              <li>审核引擎：货运6条 + æ—…客8条预置规则（运政对比、环比=0、平均运距环比、无车有量矛盾等）</li>
              <li>报表生成：货运（分市州明细/排名）+ æ—…客分市州明细（月报/年报两种模式）</li>
            </ol>
          </el-card>
        </div>

 traffic-audit-web/src/views/DataImport.vue

@@ -17,36 +17,188 @@
      <el-main>
        <div class="page-scroll">
        <h3>导入业务数据</h3>
        <el-card style="max-width:640px">
          <el-form label-width="100px">
            <el-form-item label="导入类型">
              <el-radio-group v-model="importType">
                <el-radio label="h2032">H203-2月报</el-radio>
                <el-radio label="transportAuth">运政车辆</el-radio>
                <el-radio label="trackMileage">轨迹里程</el-radio>
                <el-radio label="scaleSplit">规上规下拆分</el-radio>
                <el-radio label="freightTurnover">货运量周转量</el-radio>
              </el-radio-group>
            </el-form-item>
            <el-form-item label="报表期">
              <el-date-picker v-model="period" type="month" placeholder="选择月份" value-format="yyyy-MM" style="width:100%"></el-date-picker>
            </el-form-item>
            <el-form-item label="选择文件">
              <el-upload ref="upload" :auto-upload="false" :limit="1" accept=".xlsx,.xls"
                         :on-change="handleFileChange" :file-list="fileList">
                <el-button slot="trigger" type="primary">选择 Excel æ–‡ä»¶</el-button>
              </el-upload>
              <div class="tip">请使用对应模板：{{ templateName }}</div>
            </el-form-item>
            <el-form-item>
              <el-button type="success" @click="importData" :loading="loading">开始导入</el-button>
            </el-form-item>
          </el-form>
          <el-card shadow="hover" class="import-card" style="margin-bottom:15px">
            <div class="card-head">报表期</div>
            <el-date-picker v-model="period" type="month" placeholder="选择月份" value-format="yyyy-MM"
                            style="width:240px" @change="onPeriodChange"></el-date-picker>
            <div class="tip">选择报表期后，下方显示该月各模块的导入进度；各模块下拉互不影响，可先选好类型、挂载文件，再加入待导入队列统一执行。</div>
        </el-card>
        <el-alert v-if="result" type="success" style="margin-top:15px" closable @close="result=''">
          <div style="white-space: pre-line">{{ result }}</div>
        </el-alert>
        <el-alert v-if="error" :title="error" type="error" style="margin-top:15px" closable @close="error=''"></el-alert>

          <el-card shadow="hover" class="import-card" style="margin-bottom:15px">
            <div class="card-head">本月导入进度（{{ period || '未选择报表期' }}）
              <el-button type="text" icon="el-icon-refresh" style="float:right" @click="loadOverview">刷新</el-button>
            </div>
            <div v-if="!period" class="tip">请先在上方选择报表期</div>
            <div v-else class="overview-grid">
              <div class="ov-row" v-for="g in groups" :key="g.key">
                <div class="ov-group">{{ g.name }}</div>
                <div class="ov-item" v-for="t in g.types" :key="t.value" :class="overviewState(t.value).cls">
                  <div class="ov-name">{{ t.label }}</div>
                  <div class="ov-status">{{ overviewState(t.value).text }}</div>
                </div>
              </div>
            </div>
          </el-card>
          <el-card shadow="hover" class="import-card" style="margin-bottom:15px">
            <div class="card-head">选择类型并挂载文件
              <span class="tip" style="float:right;line-height:24px">各模块互不影响：先选类型、挂载文件，可「立即导入」或「加入队列」统一执行；也可在下方粘贴目录路径点「导入该目录」，文件夹里多个月的 Excel ä¼šæŒ‰æ–‡ä»¶åè‡ªåŠ¨è¯†åˆ«æœˆä»½ã€åˆ†åˆ«å¯¼å…¥å¯¹åº”报表期</span>
            </div>
            <el-tabs v-model="activeModule" class="module-tabs">
              <el-tab-pane v-for="g in groups" :key="g.key" :label="g.name" :name="g.key">
                <div class="module-sel">
                  <el-select v-model="moduleSel[g.key]" placeholder="选择导入类型" style="width:260px"
                             @change="onModuleChange(g.key)" clearable>
                    <el-option v-for="t in g.types" :key="t.value" :label="t.label" :value="t.value"></el-option>
                  </el-select>
                  <div v-if="isCityDirType(moduleSel[g.key])" class="module-file">
                    <div class="tip">无需选文件：自动扫描 docs/投资/输入/…/{{ period ? Number(period.slice(5)) : 'X' }}月 ç›®å½•ä¸‹å…¨éƒ¨å¸‚州报表，逐文件容错解析入库（项目主档+月度，含本月完成/建设阶段/形象进度；十五五项目自动标记）。</div>
                    <el-button size="mini" type="primary" icon="el-icon-upload2" :loading="cityDirLoading"
                               @click="importCityDir(moduleSel[g.key])">从目录批量导入</el-button>
                  </div>
                  <div v-else-if="moduleSel[g.key]" class="module-file">
                    <div class="file-name" :title="fileNames[moduleSel[g.key]]">{{ fileNames[moduleSel[g.key]] || '未选择文件' }}</div>
                    <div class="file-btns">
                      <el-upload action="#" :auto-upload="false" :show-file-list="false" accept=".xlsx,.xls"
                                 :ref="'up' + g.key" :on-change="f => onFilePicked(g.key, f)" style="display:inline-block">
                        <el-button size="mini" type="primary" plain icon="el-icon-folder-opened">选择文件</el-button>
                      </el-upload>
                      <el-button size="mini" type="primary" icon="el-icon-upload2" :disabled="!files[moduleSel[g.key]]"
                                 @click="importNow(g.key)">立即导入</el-button>
                      <el-button size="mini" type="success" plain icon="el-icon-plus" :disabled="!files[moduleSel[g.key]]"
                                 @click="addToQueue(g.key)">加入队列</el-button>
                    </div>
                    <div class="dir-import-bar">
                      <el-input v-model="dirPath" size="small" placeholder="粘贴目录路径（如 D:\数据\2026），点「导入该目录」" style="width:330px"
                                @keyup.enter.native="quickDirImport(moduleSel[g.key])" clearable></el-input>
                      <el-button size="mini" type="warning" icon="el-icon-folder" :loading="dirImporting"
                                 @click="quickDirImport(moduleSel[g.key])">导入该目录</el-button>
                      <el-button size="mini" type="text" icon="el-icon-search" @click="openDirBrowser(g.key)">浏览…</el-button>
                      <el-checkbox v-model="dirSkipImported" size="mini">跳过已导入文件</el-checkbox>
                    </div>
                    <div class="tip">目录导入：文件夹里的 Excel ä¼šæŒ‰æ–‡ä»¶åè‡ªåŠ¨è¯†åˆ«æœˆä»½ï¼ˆæ”¯æŒ 2026å¹´7月 / 2026.7 / 2026-07 / 7月），分别导入对应报表期；识别不到月份的文件会报错提示。也可点「浏览…」查找目录。</div>
                    <div v-if="dirImportFiles.length" class="dir-progress">
                      <div class="card-head" style="font-size:13px">目录导入进度</div>
                      <div v-for="f in dirImportFiles" :key="f.name" class="dir-progress-row">
                        <i :class="progIcon(f.status)"></i>
                        <span class="prog-name" :title="f.name">{{ f.name }}</span>
                        <el-tag v-if="f.period" size="mini" type="info">{{ f.period }}</el-tag>
                        <el-tag size="mini" :type="progTag(f.status)">{{ progText(f.status) }}</el-tag>
                        <span v-if="f.msg" class="queue-msg" :style="f.status === 'fail' ? 'color:#F56C6C' : 'color:#67C23A'">{{ f.msg }}</span>
                      </div>
                    </div>
                  </div>
                </div>
              </el-tab-pane>
            </el-tabs>
            <div v-if="importType" class="type-info">
              <div>模板：{{ templateName }}
                <el-link v-if="templateUrl" type="primary" icon="el-icon-download" :underline="false"
                         style="margin-left:8px" @click="downloadTemplate">下载模板</el-link>
              </div>
              <div class="tip">{{ typeDesc }}</div>
              <span v-if="importType === 'cityTaxiAuth'" class="slow-tip">该类型约 4 ä¸‡+ è¡Œï¼Œé¢„计耗时 5 åˆ†é’Ÿå·¦å³</span>
            </div>
          </el-card>


          <el-card v-if="queue.length" ref="queueCard" shadow="hover" class="import-card" style="margin-bottom:15px">
            <div class="card-head">
              å¾…导入队列（{{ queue.length }} é¡¹ï¼‰
              <el-button type="success" size="small" icon="el-icon-video-play" style="float:right"
                         :loading="queueLoading" :disabled="!pendingCount" @click="importQueue">全部导入（{{ pendingCount }}）</el-button>
            </div>
            <el-table :data="queue" border size="small" style="width:100%">
              <el-table-column label="模块" width="90">
                <template slot-scope="s">{{ s.row.moduleName }}</template>
              </el-table-column>
              <el-table-column label="导入类型" width="150">
                <template slot-scope="s">{{ s.row.typeLabel }}</template>
              </el-table-column>
              <el-table-column label="文件" min-width="200" show-overflow-tooltip>
                <template slot-scope="s">{{ s.row.fileName }}</template>
              </el-table-column>
              <el-table-column label="状态" width="110" align="center">
                <template slot-scope="s">
                  <el-tag v-if="s.row.status === 'pending'" type="info" size="mini">待导入</el-tag>
                  <el-tag v-else-if="s.row.status === 'uploading'" type="warning" size="mini" effect="dark">导入中…</el-tag>
                  <el-tag v-else-if="s.row.status === 'success'" type="success" size="mini">成功</el-tag>
                  <el-tag v-else type="danger" size="mini">失败</el-tag>
                </template>
              </el-table-column>
              <el-table-column label="结果" min-width="240">
                <template slot-scope="s">
                  <span class="queue-msg">{{ s.row.message }}</span>
                </template>
              </el-table-column>
              <el-table-column label="操作" width="130" align="center">
                <template slot-scope="s">
                  <el-button v-if="s.row.status === 'pending'" size="mini" type="primary" plain @click="importOne(s.row)">导入</el-button>
                  <el-button v-if="s.row.status !== 'uploading'" size="mini" type="danger" plain icon="el-icon-delete"
                             @click="removeQueueItem(s.row)"></el-button>
                </template>
              </el-table-column>
            </el-table>
            <div class="tip" style="margin-top:8px">导入为逐个执行；同报表期重复导入会先删除旧数据再写入（幂等，不会重复存两份）。</div>
          </el-card>

          <el-dialog :title="'浏览目录 â€” ' + (dirTypeLabel || '')" :visible.sync="dirDialog" width="640px" top="6vh" append-to-body>
            <div class="dir-toolbar">
              <el-button size="mini" type="text" icon="el-icon-refresh" :disabled="dirLoading" @click="loadDirs(dirCurrent)">刷新</el-button>
              <el-button size="mini" type="text" icon="el-icon-folder-opened" @click="loadDirs('')">数据目录 docs</el-button>
              <el-button size="mini" type="text" icon="el-icon-back" :disabled="!dirParent" @click="goDirParent">上级目录</el-button>
            </div>
            <div class="dir-path" :title="dirCurrent">{{ dirCurrent || '（加载中…）' }}</div>
            <div class="dir-body" v-loading="dirLoading">
              <div v-if="!dirDirs.length" class="dir-empty">当前目录下没有子文件夹，可直接选择当前文件夹导入</div>
              <div v-for="d in dirDirs" :key="d.path" class="dir-row" :title="d.path + '（双击立即导入该文件夹）'" @click="loadDirs(d.path)" @dblclick="dblImportDir(d)">
                <i class="el-icon-folder"></i><span>{{ d.name }}</span>
              </div>
            </div>
            <div class="dir-files">
              <div class="tip">单击文件夹进入子文件夹；<b>双击目标文件夹立即导入</b>其中全部 Excel；也可进入后点下方按钮。导入时会按文件名自动识别月份。</div>
              <div v-if="dirExcelCount === 0" class="tip">当前文件夹内没有 Excel æ–‡ä»¶ï¼ˆ.xlsx/.xls）</div>
              <div v-else class="tip">当前文件夹内 Excel：{{ dirExcelCount }} ä¸ª â€”— {{ dirFiles.slice(0, 6).join('、') }}{{ dirFiles.length > 6 ? ' ç­‰' : '' }}（仅导入直接位于该文件夹的文件）</div>
            </div>
            <span slot="footer">
              <el-button size="small" @click="dirDialog = false">取消</el-button>
              <el-button size="small" type="primary" :disabled="dirExcelCount === 0 || dirImporting" :loading="dirImporting" @click="confirmDirImport">导入当前目录</el-button>
            </span>
          </el-dialog>

          <el-card shadow="never" style="margin-top:15px" class="batch-card">
            <div slot="header" class="card-head">
              å¯¼å…¥è®°å½•ï¼ˆ{{ period || '全部报表期' }}）
              <el-button type="text" icon="el-icon-refresh" style="float:right" @click="loadBatches">刷新</el-button>
            </div>
            <el-table :data="batches" border size="small" v-loading="batchLoading" style="width:100%">
              <el-table-column prop="importType" label="导入类型" width="150">
                <template slot-scope="s">{{ typeLabel(s.row.importType) }}</template>
              </el-table-column>
              <el-table-column prop="reportPeriod" label="报表期" width="100"></el-table-column>
              <el-table-column prop="fileName" label="文件名" min-width="220" show-overflow-tooltip></el-table-column>
              <el-table-column prop="totalRows" label="总行数" width="90"></el-table-column>
              <el-table-column prop="successRows" label="成功" width="80">
                <template slot-scope="s">
                  <span style="color:#67C23A" v-if="s.row.successRows > 0">{{ s.row.successRows }}</span>
                  <span v-else>0</span>
                </template>
              </el-table-column>
              <el-table-column prop="failRows" label="失败" width="70">
                <template slot-scope="s">
                  <el-tag v-if="s.row.failRows > 0" size="mini" type="danger">{{ s.row.failRows }}</el-tag>
                  <span v-else style="color:#909399">0</span>
                </template>
              </el-table-column>
              <el-table-column prop="createdAt" label="导入时间" width="165"></el-table-column>
              <el-table-column label="状态" width="90">
                <template slot-scope="s">
                  <el-tag v-if="s.row.failRows > 0" size="mini" type="warning" effect="plain">部分失败</el-tag>
                  <el-tag v-else-if="s.row.successRows > 0" size="mini" type="success" effect="plain">成功</el-tag>
                  <el-tag v-else size="mini" type="info" effect="plain">无数据</el-tag>
                </template>
              </el-table-column>
            </el-table>
          </el-card>
        </div>
      </el-main>
    </el-container>
@@ -55,63 +207,555 @@
<script>
import AppHeader from '@/components/AppHeader.vue'
import api from '@/api'
const TYPE_LABELS = {
  h2032: 'H203-2月报', transportAuth: '运政车辆', trackMileage: '轨迹里程', scaleSplit: '规上规下拆分',
  freightTurnover: '货运量周转量', passengerMonthly: 'H203-1旅客月报', passengerIndividual: '个体客运量/周转量',
  passengerAuth: '旅客运政车辆数', energyMonthly: 'H204能耗季报', energyAuth: '能耗车辆运政信息',
  investment: '投资月报（客运站场）', investmentLogistics: '投资月报（物流园区）', investmentSystem: '投资系统导出',
  investCityPassenger: '市州单表（客运站场）', investCityLogistics: '市州单表（物流园区）',
  'INVEST_客运站场_CITY': '市州单表（客运站场）', 'INVEST_物流园区_CITY': '市州单表（物流园区）',
  cityBus: '城市公交月报', cityTaxi: '巡游出租月报', cityTaxiAuth: '出租车运政车辆',
  H2032: 'H203-2月报', H2031: 'H203-1旅客月报', H204: 'H204能耗季报', PASSENGER_AUTH: '旅客运政车辆数',
  PASSENGER_INDIVIDUAL: '个体客运量/周转量', ENERGY_AUTH: '能耗车辆运政信息', TRANSPORT_AUTH: '运政车辆',
  TRACK_MILEAGE: '轨迹里程', SCALE_SPLIT: '规上规下拆分', FREIGHT_TURNOVER: '货运量周转量',
  INVEST_SYSTEM: '投资系统导出', CITY_BUS: '城市公交月报', CITY_TAXI: '巡游出租月报', CITY_TAXI_AUTH: '出租车运政车辆'
}
const BATCH_TYPE_MAP = {
  H2032: 'h2032', TRANSPORT_AUTH: 'transportAuth', TRACK_MILEAGE: 'trackMileage',
  SCALE_SPLIT: 'scaleSplit', FREIGHT_TURNOVER: 'freightTurnover',
  H2031: 'passengerMonthly', PASSENGER_AUTH: 'passengerAuth', PASSENGER_INDIVIDUAL: 'passengerIndividual',
  H204: 'energyMonthly', ENERGY_AUTH: 'energyAuth',
  CITY_BUS: 'cityBus', CITY_TAXI: 'cityTaxi', CITY_TAXI_AUTH: 'cityTaxiAuth',
  INVEST_SYSTEM: 'investmentSystem'
}
export default {
  components: { AppHeader },
  name: 'DataImport',
  data() {
    return {
      importType: 'h2032',
      period: '',
      file: null,
      fileList: [],
      loading: false,
      period: (() => { const d = new Date(); return d.getFullYear() + '-' + String(d.getMonth() + 1).padStart(2, '0') })(),
      queue: [],
      queueLoading: false,
      cityDirLoading: false,
      dirDialog: false,
      dirKey: '',
      dirCurrent: '',
      dirParent: '',
      dirDirs: [],
      dirExcelCount: 0,
      dirFiles: [],
      dirLoading: false,
      dirImporting: false,
      dirPath: '',
      dirImportFiles: [],
      dirSkipImported: true,
      result: '',
      error: ''
      error: '',
      batches: [],
      batchLoading: false,
      moduleSel: { freight: 'h2032', passenger: '', city: '', energy: '', invest: '' },
      activeModule: 'freight',
      files: {},
      fileNames: {},
      overview: {},
      groups: [
        {
          key: 'freight', name: '货运', types: [
            { value: 'h2032', label: 'H203-2月报' },
            { value: 'transportAuth', label: '运政车辆' },
            { value: 'trackMileage', label: '轨迹里程' },
            { value: 'scaleSplit', label: '规上规下拆分' },
            { value: 'freightTurnover', label: '货运量周转量' }
          ]
        },
        {
          key: 'passenger', name: '公路旅客', types: [
            { value: 'passengerMonthly', label: 'H203-1旅客月报' },
            { value: 'passengerAuth', label: '运政车辆数' },
            { value: 'passengerIndividual', label: '个体客运量/周转量' }
          ]
        },
        {
          key: 'city', name: '城市客运', types: [
            { value: 'cityBus', label: '城市公交月报' },
            { value: 'cityTaxi', label: '巡游出租月报' },
            { value: 'cityTaxiAuth', label: '出租车运政车辆' }
          ]
        },
        {
          key: 'invest', name: '投资', types: [
            { value: 'investment', label: '投资月报（客运站场）' },
            { value: 'investmentLogistics', label: '投资月报（物流园区）' },
            { value: 'investmentSystem', label: '投资系统导出' },
            { value: 'investCityPassenger', label: '市州单表批量导入（客运站场）' },
            { value: 'investCityLogistics', label: '市州单表批量导入（物流园区）' }
          ]
        },
        {
          key: 'energy', name: '能耗', types: [
            { value: 'energyMonthly', label: 'H204能耗季报' },
            { value: 'energyAuth', label: '能耗车辆运政信息' }
          ]
        }
      ]
    }
  },
  computed: {
    pendingCount() { return this.queue.filter(x => x.status === 'pending').length },
    dirTypeLabel() {
      const t = this.moduleSel[this.dirKey]
      if (!t) return ''
      for (const g of this.groups) {
        const found = g.types.find(x => x.value === t)
        if (found) return g.name + ' / ' + found.label
      }
      return t
    },
    typeDesc() {
      const map = {
        h2032: '企业级货运月报：用于规上货运量审核与分市州汇总（17 å¸‚州企业明细）。',
        transportAuth: '运政车辆档案：用于车辆信息核对（吨位/车型/燃料类型）。',
        trackMileage: '轨迹里程数据：用于里程与运距校验。',
        scaleSplit: '规上规下拆分：全省+17 å¸‚州货运量/周转量拆分结果。',
        freightTurnover: '货运量周转量：全省+17 å¸‚州月度合计（今年 1-N æœˆ + åŽ»å¹´ï¼‰ã€‚',
        passengerMonthly: '公路旅客月报：企业级明细 + è¿æ”¿è½¦è¾†æ•°ä¸¤ä¸ª sheet（运政车辆数也可单独导入）。',
        passengerAuth: '旅客运政车辆数：独立模板（企业代码/企业名称/车辆数/载客位数），用于运营车辆核对；也可随 H203-1 æœˆæŠ¥ç¬¬äºŒä¸ª sheet ä¸€å¹¶å¯¼å…¥ã€‚',
        passengerIndividual: '个体客运量/周转量：企业线下汇报数据（所属地区/企业代码/企业名称/个体客运量/个体旅客周转量），导入后自动填入分市州表“其中个体”行。',
        energyMonthly: '能耗季报：能耗明细 + è¿æ”¿è½¦è¾†ä¿¡æ¯ä¸¤ä¸ª sheet（运政信息也可单独导入，季度末月生成汇总表）。',
        energyAuth: '能耗车辆运政信息：独立模板（车牌号/车辆类型/燃料类型/标记吨位/准牵引质量），用于能耗审核对比；也可随 H204 å­£æŠ¥ç¬¬äºŒä¸ª sheet ä¸€å¹¶å¯¼å…¥ã€‚',
        investment: '投资月报（客运站场）：市州汇总大表，导入后生成 4 å¼ é¢†å¯¼æŠ¥è¡¨ã€‚',
        investmentLogistics: '投资月报（物流园区）：分项目投资完成情况 sheet。',
        investmentSystem: '投资系统导出：用于与月报数据跨表校验。',
        investCityPassenger: '无需选文件：自动扫描 docs/投资/输入/客运（客运站）/X月 ç›®å½•å…¨éƒ¨å¸‚州报表，容错解析入库（含本月完成/建设阶段/形象进度，十五五项目自动标记）。',
        investCityLogistics: '无需选文件：自动扫描 docs/投资/输入/物流（物流园区）/X月 ç›®å½•å…¨éƒ¨å¸‚州报表，容错解析入库（含本月完成/建设阶段/形象进度，十五五项目自动标记）。',
        cityBus: '城市公交月报：企业级运营数据，含轨道/轮渡字段。',
        cityTaxi: '巡游出租月报：市州级 17 è¡Œè¿è¥æ•°æ®ã€‚',
        cityTaxiAuth: '出租车运政车辆：车辆级明细（约 4 ä¸‡+ è¡Œï¼‰ï¼Œç”¨äºŽè¿è¥è½¦æ•°å¯¹æ¯”。'
      }
      return map[this.importType] || ''
    },
    templateName() {
      const map = {
        h2032: '模板_交企统H203-2表_道路货物运输月度生产情况.xlsx',
        transportAuth: '模板_运政车辆.xlsx',
        trackMileage: '模板_轨迹里程.xlsx',
        scaleSplit: '模板_规上规下拆分运输量.xlsx',
        freightTurnover: '模板_货运量周转量.xlsx'
        freightTurnover: '模板_货运量周转量.xlsx',
        passengerMonthly: '公路旅客运输月度生产情况.xlsx（含运政车辆数sheet）',
        passengerAuth: '模板_公路旅客运政车辆数.xlsx（列：企业代码/企业名称/车辆数/载客位数）',
        passengerIndividual: '个体客运量汇总.xlsx（列：所属地区/企业代码/企业名称/个体客运量/个体旅客周转量）',
        energyMonthly: '道路货运车辆能源消耗情况（2026年）.xlsx（能耗明细+运政车辆信息两sheet）',
        energyAuth: '模板_能耗车辆运政信息.xlsx（列：车牌号/车辆类型/燃料类型/标记吨位/准牵引质量）',
        investment: '7月客运站投资明细表（市州汇总大表，给领导）.xlsx',
        investmentLogistics: '7月物流站场投资明细.xls（分项目投资完成情况sheet）',
        investmentSystem: '查询结果(投资系统-客运+物流 2026.7).xls',
        investCityPassenger: '—（批量扫描目录，无需模板）',
        investCityLogistics: '—（批量扫描目录，无需模板）',
        cityBus: '导入_城市公共交通月度运营情况（YYYYå¹´M月）.xls/.xlsx（企业级明细，取公共汽电车字段）',
        cityTaxi: '导入_巡游出租汽车运营服务情况月报（YYYYå¹´M月）.xls（市州级17行）',
        cityTaxiAuth: '导入_出租车信息(运政车辆信息).xls（车辆级明细，用于运营车数对比）'
      }
      return map[this.importType] || ''
    },
    endpoint() {
    templateUrl() {
      const map = {
        h2032: '货运/模板_交企统H203-2表_道路货物运输月度生产情况.xlsx',
        transportAuth: '货运/模板_运政车辆.xlsx',
        trackMileage: '货运/模板_轨迹里程.xlsx',
        scaleSplit: '货运/模板_规上规下拆分运输量.xlsx',
        freightTurnover: '货运/模板_货运量周转量.xlsx',
        passengerMonthly: '公路旅客/模板_交企统H203-1表_公路旅客运输月度生产情况.xlsx',
        passengerAuth: '公路旅客/模板_公路旅客运政车辆数.xlsx',
        passengerIndividual: '',
        energyMonthly: '能耗/模板_道路货运车辆能源消耗情况（2026）.xlsx',
        energyAuth: '能耗/模板_能耗车辆运政信息.xlsx',
        cityBus: '城市客运/导入模板_城市公交.xlsx',
        cityTaxi: '城市客运/导入模板_巡游出租.xlsx',
        cityTaxiAuth: '城市客运/导入模板_出租车信息(运政车辆信息).xls',
        investment: '投资/输入/客运（客运站）/更新_7月客运站投资明细表（市州汇总大表，给领导）.xlsx',
        investmentLogistics: '投资/输入/物流（物流园区）/更新_7月物流站场投资明细.xls',
        investmentSystem: '投资/模板_查询结果(投资系统-客运+物流 2026.7).xls'
      }
      return map[this.importType] || ''
    }
  },
  methods: {
    typeLabel(t) { return TYPE_LABELS[t] || t },
    downloadTemplate() {
      if (!this.templateUrl) return
      window.open('/api/templates/' + this.templateUrl)
    },
    onModuleChange(key) {
      this.importType = this.moduleSel[key] || ''
      this.dirPath = (this.importType && localStorage.getItem('dirLast_' + this.importType)) || ''
    },
    onPeriodChange() { this.loadOverview(); this.loadBatches() },
    endpoint(t) {
      const map = {
        h2032: '/import/h2032',
        transportAuth: '/import/transportAuth',
        trackMileage: '/import/trackMileage',
        scaleSplit: '/import/scaleSplit',
        freightTurnover: '/import/freightTurnover'
        freightTurnover: '/import/freightTurnover',
        passengerMonthly: '/import/passengerMonthly',
        passengerAuth: '/import/passengerAuth',
        passengerIndividual: '/import/passengerIndividual',
        energyMonthly: '/import/energyMonthly',
        energyAuth: '/import/energyAuth',
        investment: '/import/investment',
        investmentLogistics: '/import/investment',
        investmentSystem: '/import/investmentSystem',
        cityBus: '/import/cityBus',
        cityTaxi: '/import/cityTaxi',
        cityTaxiAuth: '/import/cityTaxiAuth'
      }
      return map[this.importType]
      return map[t] || ''
    },
    openDirBrowser(key) {
      const type = this.moduleSel[key]
      if (!type) { this.$message.warning('请先选择导入类型'); return }
      this.dirKey = key
      this.dirDialog = true
      const last = localStorage.getItem('dirLast_' + type)
      this.loadDirs(last || '')
    },
    loadDirs(path) {
      this.dirLoading = true
      api.get('/import/dirs', { params: { path: path || '' } })
        .then(res => {
          const d = (res && res.data) || {}
          this.dirCurrent = d.current || ''
          this.dirParent = d.parent || ''
          this.dirDirs = d.dirs || []
          this.dirExcelCount = d.excelCount || 0
          this.dirFiles = d.files || []
        })
        .catch(e => { this.$message.error((e.response && e.response.data && e.response.data.message) || '目录加载失败') })
        .finally(() => { this.dirLoading = false })
    },
    goDirParent() { if (this.dirParent) this.loadDirs(this.dirParent) },
    dblImportDir(d) {
      this.dirDialog = false
      this.runDirImport(this.moduleSel[this.dirKey], d.path)
    },
    confirmDirImport() {
      if (!this.dirCurrent) return
      this.runDirImport(this.moduleSel[this.dirKey], this.dirCurrent)
    },
    quickDirImport(type) {
      if (!type) { this.$message.warning('请先选择导入类型'); return }
      this.runDirImport(type, this.dirPath)
    },
    runDirImport(type, dir) {
      if (!type) { this.$message.warning('请先选择导入类型'); return }
      if (!dir || !dir.trim()) { this.$message.warning('请先填写目录路径（或点「浏览…」选择）'); return }
      dir = dir.trim()
      this.dirImporting = true
      this.dirImportFiles = []
      api.get('/import/dirs', { params: { path: dir } })
        .then(res => {
          const d = (res && res.data) || {}
          const files = (d.files || []).filter(n => /\.(xlsx|xls)$/i.test(n))
          if (!files.length) { this.$message.warning('该目录没有 Excel æ–‡ä»¶ï¼ˆ.xlsx/.xls）：' + dir); this.dirImporting = false; return }
          localStorage.setItem('dirLast_' + type, dir)
          this.dirPath = dir
          this.dirImportFiles = files.map(n => ({ name: n, status: 'pending', period: '', msg: '' }))
          const run = (i) => {
            if (i >= files.length) {
              this.dirImporting = false
              const ok = this.dirImportFiles.filter(x => x.status === 'success').length
              const fail = this.dirImportFiles.filter(x => x.status === 'fail').length
              const skip = this.dirImportFiles.filter(x => x.status === 'skipped').length
              if (fail > 0) this.$message.warning('目录导入完成：成功 ' + ok + '，失败 ' + fail + '，跳过 ' + skip + '（失败原因见列表）')
              else this.$message.success('目录导入完成：成功 ' + ok + '，跳过 ' + skip)
              this.afterImport()
              return
            }
            const row = this.dirImportFiles[i]
            row.status = 'importing'
            const fd = new FormData()
            fd.append('type', type)
            fd.append('period', this.period || '')
            fd.append('skipImported', this.dirSkipImported ? 'true' : 'false')
            fd.append('path', dir.replace(/[\\/]+$/, '') + '\\' + files[i])
            api.post('/import/fromDirFile', fd, { timeout: 600000 })
              .then(res => {
                const r = (res && res.data) || {}
                row.period = r.period || ''
                if (r.skipped) { row.status = 'skipped'; row.msg = r.error || '已跳过' }
                else if (r.fail > 0 || r.error) { row.status = 'fail'; row.msg = r.error || ('失败 ' + r.fail + ' æ¡') }
                else { row.status = 'success'; row.msg = '解析 ' + r.success + ' æ¡' }
              })
              .catch(e => { row.status = 'fail'; row.msg = (e.response && e.response.data && e.response.data.message) || '导入失败' })
              .finally(() => run(i + 1))
          }
          run(0)
        })
        .catch(e => {
          this.dirImporting = false
          this.$message.error((e.response && e.response.data && e.response.data.message) || '目录不存在或无法访问：' + dir)
        })
    },
    progText(s) { return s === 'pending' ? '待导入' : s === 'importing' ? '导入中…' : s === 'success' ? '成功' : s === 'skipped' ? '已跳过' : '失败' },
    progTag(s) { return s === 'pending' ? 'info' : s === 'importing' ? 'warning' : s === 'success' ? 'success' : s === 'skipped' ? 'info' : 'danger' },
    progIcon(s) { return s === 'pending' ? 'el-icon-time' : s === 'importing' ? 'el-icon-loading' : s === 'success' ? 'el-icon-success' : s === 'skipped' ? 'el-icon-minus' : 'el-icon-error' },
    onFilePicked(key, file) {
      this.$set(this.files, this.moduleSel[key], file.raw)
      this.$set(this.fileNames, this.moduleSel[key], file.name)
      const up = this.$refs['up' + key]
      if (up && up.clearFiles) up.clearFiles()
    },
    importNow(key) {
      const type = this.moduleSel[key]
      if (!type) return
      if (this.isCityDirType(type)) {
        this.importCityDir(type)
        this.moduleSel[key] = ''
        this.importType = ''
        return
      }
      const file = this.files[type]
      if (!file) { this.$message.warning('请先为该类型选择文件'); return }
      if (!this.period) { this.$message.warning('请先选择报表期'); return }
      const g = this.groups.find(x => x.key === key)
      const t = g.types.find(x => x.value === type)
      const row = {
        id: Date.now() + Math.random(),
        moduleKey: key,
        moduleName: g.name,
        type,
        typeLabel: t.label,
        file,
        fileName: this.fileNames[type] || file.name,
        status: 'pending',
        message: ''
      }
      this.importOne(row).then(() => {
        if ((row.type === 'investment' || row.type === 'investmentLogistics') && row.status === 'success') {
          this.checkInvest(this.period)
        }
        this.afterImport()
        this.moduleSel[key] = ''
        this.importType = ''
        this.files[type] = null
        this.$delete(this.fileNames, type)
      })
    },
    isCityDirType(t) { return t === 'investCityPassenger' || t === 'investCityLogistics' },
    importCityDir(type) {
      if (!this.period) { this.$message.warning('请先选择报表期'); return }
      const category = type === 'investCityPassenger' ? '客运站场' : '物流园区'
      const fd = new FormData()
      fd.append('period', this.period)
      fd.append('category', category)
      this.cityDirLoading = true
      api.post('/import/investCityBatch', fd, { timeout: 300000 })
        .then(res => {
          const d = (res && res.data) || {}
          if (!d.files) {
            this.$message.error((res && res.message) || '批量导入失败（请确认报表期目录存在）')
            return
          }
          const files = d.files || []
          const errCount = files.filter(f => f.error || f.success === 0).length
          const html = files.map(f =>
            '<div style="margin:6px 0;line-height:1.6"><b>' + (f.fileName || '') + '</b>' +
            (f.city ? '（' + f.city + '）' : '') + '：解析 ' + (f.success || 0) + ' ä¸ªé¡¹ç›®' +
            (f.error ? ' <span style="color:#F56C6C">' + f.error + '</span>' : '') + '</div>'
          ).join('')
          this.$alert(html, '市州单表批量导入完成：共 ' + d.total + ' æ¡ï¼ŒæˆåŠŸ ' + d.success + ' æ¡' +
            (d.fail > 0 ? '，失败 ' + d.fail + ' æ¡' : '') +
            '（十五五项目匹配 ' + d.fiveYearMatched + '/' + d.fiveYearTemplateProjects + '）', {
            dangerouslyUseHTMLString: true,
            type: errCount > 0 ? 'warning' : 'success',
            confirmButtonText: '知道了'
          })
          this.afterImport()
        })
        .catch(e => {
          this.$message.error((e.response && e.response.data && e.response.data.message) || '批量导入失败')
        })
        .finally(() => { this.cityDirLoading = false })
    },
    addToQueue(key) {
      const type = this.moduleSel[key]
      if (!type) return
      const file = this.files[type]
      if (!file) { this.$message.warning('请先为该类型选择文件'); return }
      const g = this.groups.find(x => x.key === key)
      const t = g.types.find(x => x.value === type)
      this.queue.push({
        id: Date.now() + Math.random(),
        moduleKey: key,
        moduleName: g.name,
        type,
        typeLabel: t.label,
        file,
        fileName: this.fileNames[type] || file.name,
        status: 'pending',
        message: ''
      })
      this.moduleSel[key] = ''
      this.importType = ''
      this.files[type] = null
      this.$delete(this.fileNames, type)
    },
    removeQueueItem(row) {
      const i = this.queue.indexOf(row)
      if (i >= 0) this.queue.splice(i, 1)
    },
    importOne(row) {
      if (!this.period) { this.$message.warning('请先选择报表期'); return Promise.resolve() }
      row.status = 'uploading'
      row.message = ''
      const fd = new FormData()
      fd.append('file', row.file)
      fd.append('period', this.period)
      if (row.type === 'investment' || row.type === 'investmentLogistics') {
        fd.append('category', row.type === 'investment' ? '客运站场' : '物流园区')
      }
      return api.post(this.endpoint(row.type), fd, { headers: { 'Content-Type': 'multipart/form-data' }, timeout: 600000 })
        .then(res => { row.status = 'success'; row.message = res.data || '导入成功' })
        .catch(e => { row.status = 'fail'; row.message = (e.response && e.response.data && e.response.data.message) || '导入失败' })
        .finally(() => {})
    },
    importQueue() {
      if (!this.period) { this.$message.warning('请先选择报表期'); return Promise.resolve(false) }
      const pending = this.queue.filter(x => x.status === 'pending')
      if (pending.length === 0) { this.$message.warning('队列中没有待导入项'); return Promise.resolve(false) }
      this.queueLoading = true
      return new Promise(resolve => {
        const run = (i) => {
          if (i >= pending.length) {
            this.queueLoading = false
            this.afterImport()
            resolve(true)
            return
          }
          this.importOne(pending[i]).then(() => {
            const t = pending[i].type
            if ((t === 'investment' || t === 'investmentLogistics') && pending[i].status === 'success') {
              this.checkInvest(this.period)
            }
            run(i + 1)
          })
        }
        run(0)
      })
    },
    afterImport() { this.loadOverview(); this.loadBatches() },
    loadOverview() {
      if (!this.period) return
      api.get('/import/batches', { params: { period: this.period, limit: 200 } })
        .then(res => {
          const map = {}
          const records = (res.data && res.data.records) || []
          records.forEach(r => {
            const key = this.batchKeyToType(r.importType)
            if (!key) return
            const cur = map[key]
            if (!cur || (cur.latestId || 0) < (r.id || 0)) {
              map[key] = { totalRows: r.totalRows, successRows: r.successRows, failRows: r.failRows, latestId: r.id }
            }
          })
          this.overview = map
        })
        .catch(() => {})
    },
    batchKeyToType(k) {
      if (BATCH_TYPE_MAP[k]) return BATCH_TYPE_MAP[k]
      if (k && k.indexOf('INVEST_') === 0) {
        if (k.indexOf('_CITY') >= 0) return k === 'INVEST_物流园区_CITY' ? 'investCityLogistics' : 'investCityPassenger'
        return k === 'INVEST_物流园区' ? 'investmentLogistics' : 'investment'
      }
      return ''
    },
    overviewState(type) {
      const o = this.overview[type]
      if (!o) return { cls: 'ov-empty', text: '未导入' }
      if (o.failRows > 0) return { cls: 'ov-fail', text: '部分失败（失败 ' + o.failRows + ' è¡Œï¼‰' }
      if (o.successRows > 0) return { cls: 'ov-ok', text: '已导入 ' + o.successRows + ' è¡Œ' }
      return { cls: 'ov-empty', text: '无数据' }
    },
    loadBatches() {
      this.batchLoading = true
      const params = { limit: 50 }
      if (this.period) params.period = this.period
      api.get('/import/batches', { params })
        .then(res => { this.batches = (res.data && res.data.records) || [] })
        .catch(() => {})
        .finally(() => { this.batchLoading = false })
    },
    checkInvest(period) {
      const fd = new FormData()
      fd.append('period', period)
      fd.append('reportType', 'INVEST')
      api.post('/audit/execute', fd, { timeout: 120000 })
        .then(res => {
          const list = res.data || []
          const pending = list.filter(x => x.status === 'PENDING')
          if (pending.length > 0) {
            const html = pending.map(x => {
              const name = x.enterpriseName || x.actualValue || ''
              return '<div style="margin:8px 0;line-height:1.6"><b>' + (x.ruleName || '') + '</b>：' + name +
                '<br/>实际：' + (x.actualValue || '') + '　基准：' + (x.thresholdValue || '') +
                '<br/>差异：' + (x.deviation || '') + '</div>'
            }).join('')
            this.$alert(html, '投资数据与投资系统不一致（' + pending.length + ' æ¡ï¼‰', {
              dangerouslyUseHTMLString: true, type: 'warning', confirmButtonText: '知道了'
            })
          } else {
            this.$message.success('已与投资系统核对，本月数据一致')
          }
        })
        .catch(() => {})
    }
  },
  methods: {
    handleFileChange(file) { this.file = file.raw },
    importData() {
      if (!this.file) { this.error = '请选择文件'; return }
      if (!this.period) { this.error = '请选择报表期'; return }
      this.loading = true; this.error = ''; this.result = ''
      let fd = new FormData()
      fd.append('file', this.file)
      fd.append('period', this.period)
      api.post(this.endpoint, fd, { headers: { 'Content-Type': 'multipart/form-data' } })
        .then(res => {
          this.result = res.data || '导入成功'
          this.fileList = []
          this.file = null
        })
        .catch(e => { this.error = (e.response && e.response.data && e.response.data.message) || '导入失败' })
        .finally(() => { this.loading = false })
    }
  mounted() {
    this.loadBatches()
    this.loadOverview()
  }
}
</script>
<style scoped>
.tip { font-size: 12px; color: #909399; margin-top: 6px; }
.el-header { background: #409EFF; color: white; line-height: 60px; font-size: 18px; }
.import-card { margin-bottom: 0; }
.card-head { font-weight: 600; margin-bottom: 6px; }
.module-tabs >>> .el-tabs__header { margin-bottom: 12px; }
.module-sel { max-width: 480px; }
.group-label { font-size: 13px; color: #606266; font-weight: 600; margin-bottom: 6px; padding-left: 6px; border-left: 3px solid #409EFF; }
.module-file { margin-top: 8px; }
.file-name { font-size: 12px; color: #606266; background: #F5F7FA; border: 1px solid #EBEEF5; border-radius: 4px; padding: 4px 8px; margin-bottom: 6px; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
.file-btns { display: flex; gap: 6px; }
.type-info { margin-top: 12px; color: #606266; font-size: 13px; background: #F5F7FA; border-radius: 4px; padding: 8px 10px; }
.tip { font-size: 12px; color: #909399; margin-top: 6px; line-height: 1.5; }
.slow-tip { font-size: 12px; color: #E6A23C; margin-left: 8px; }
.overview-grid { display: flex; flex-direction: column; gap: 8px; }
.ov-row { display: flex; align-items: stretch; gap: 8px; }
.ov-group { flex: none; width: 90px; display: flex; align-items: center; font-weight: 600; color: #606266; font-size: 13px; }
.ov-item { flex: 1; min-width: 0; border: 1px solid #EBEEF5; border-radius: 6px; padding: 6px 8px; background: #FAFAFA; }
.ov-item.ov-ok { background: #F0F9EB; border-color: #E1F3D8; }
.ov-item.ov-fail { background: #FDF6EC; border-color: #FAECD8; }
.ov-name { font-size: 12px; color: #303133; }
.ov-status { font-size: 12px; margin-top: 2px; }
.ov-ok .ov-status { color: #67C23A; }
.ov-fail .ov-status { color: #E6A23C; }
.ov-empty .ov-status { color: #C0C4CC; }
.queue-msg { font-size: 12px; color: #606266; word-break: break-all; white-space: pre-line; }
.dir-import-bar { display: flex; align-items: center; gap: 8px; margin: 6px 0 4px; flex-wrap: wrap; }
.dir-progress { margin-top: 8px; border: 1px solid #EBEEF5; border-radius: 4px; padding: 8px; background: #FAFAFA; }
.dir-progress-row { display: flex; align-items: center; gap: 8px; padding: 4px 2px; font-size: 12px; color: #303133; flex-wrap: wrap; }
.dir-progress-row i { color: #409EFF; }
.dir-progress-row .prog-name { min-width: 0; max-width: 380px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.dir-progress-row .queue-msg { width: 100%; padding-left: 22px; }
.dir-toolbar { margin-bottom: 6px; }
.dir-path { font-size: 12px; color: #606266; background: #F5F7FA; border: 1px solid #EBEEF5; border-radius: 4px; padding: 6px 8px; margin-bottom: 8px; word-break: break-all; }
.dir-body { max-height: 320px; overflow-y: auto; border: 1px solid #EBEEF5; border-radius: 4px; }
.dir-row { display: flex; align-items: center; gap: 6px; padding: 7px 10px; cursor: pointer; font-size: 13px; color: #303133; }
.dir-row:hover { background: #ECF5FF; color: #409EFF; }
.dir-row i { color: #E6A23C; }
.dir-empty { padding: 14px; font-size: 12px; color: #909399; text-align: center; }
.dir-files { margin-top: 8px; }

</style>

 traffic-audit-web/src/views/DataView.vue

@@ -24,6 +24,11 @@
              <el-radio-button label="trackMileage">轨迹里程</el-radio-button>
              <el-radio-button label="scaleSplit">规上规下拆分</el-radio-button>
              <el-radio-button label="freightTurnover">货运量周转量</el-radio-button>
              <el-radio-button label="h2031">H203-1旅客月报</el-radio-button>
              <el-radio-button label="passengerAuth">旅客运政车辆</el-radio-button>
              <el-radio-button label="cityBus">城市公交月报</el-radio-button>
              <el-radio-button label="cityTaxi">巡游出租月报</el-radio-button>
              <el-radio-button label="cityTaxiAuth">出租车运政车辆</el-radio-button>
            </el-radio-group>
          </el-form-item>
          <el-form-item label="报表期">
@@ -34,12 +39,13 @@
          </el-form-item>
          <el-form-item>
            <el-button type="primary" @click="loadData">查询</el-button>
            <el-button type="success" icon="el-icon-full-screen" @click="toggleFullscreen">全屏查看</el-button>
          </el-form-item>
        </el-form>
        <div style="color:#909399;font-size:12px;margin-bottom:6px">
          å…± {{ total }} æ¡è®°å½•ï¼Œå½“前第 {{ page }} é¡µ
        </div>
        <div class="table-area">
        <div class="table-area" ref="tableArea">
        <el-table :data="records" border v-loading="loading" size="small" style="width:100%" height="100%">
          <el-table-column v-for="c in columns" :key="c.prop" :prop="c.prop" :label="c.label" :min-width="c.width" show-overflow-tooltip>
            <template slot-scope="scope">
@@ -102,15 +108,34 @@
        this.loading = false
      })
    },
    toggleFullscreen() {
      const el = this.$refs.tableArea
      if (!document.fullscreenElement) {
        if (el && el.requestFullscreen) el.requestFullscreen()
        else this.$message.warning("浏览器不支持全屏")
      } else if (document.exitFullscreen) {
        document.exitFullscreen()
      }
    },
    formatCell(v) {
      if (v === null || v === undefined || v === '') return '-'
      return v
    }
  },
  mounted() {
    const q = this.$route.query
    if (q.type) this.type = q.type
    if (q.period) this.period = q.period
    if (q.keyword) this.keyword = q.keyword
    this.loadData()
  }
}
</script>
<style scoped>
.el-header { background: #409EFF; color: white; line-height: 60px; font-size: 18px; }
#app .table-area:fullscreen {
  padding: 20px;
  background: #fff;
  overflow: auto;
}
</style>

 traffic-audit-web/src/views/ExplainReview.vue

@@ -16,33 +16,43 @@
      </el-aside>
      <el-main>
        <h3>企业解释</h3>
        <el-form :inline="true">
        <el-form :inline="true" @submit.native.prevent>
          <el-form-item label="报表类型">
            <el-select v-model="reportType" style="width:190px" @change="onTypeChange">
              <el-option label="货运（H203-2）" value="H2032"></el-option>
              <el-option label="公路旅客（H203-1）" value="H2031"></el-option>
              <el-option label="城市公交（CITY_BUS）" value="CITY_BUS"></el-option>
              <el-option label="巡游出租（CITY_TAXI）" value="CITY_TAXI"></el-option>
            </el-select>
          </el-form-item>
          <el-form-item label="报表期">
            <el-date-picker v-model="period" type="month" placeholder="全部" value-format="yyyy-MM" clearable style="width:140px" @change="loadData"></el-date-picker>
          </el-form-item>
          <el-form-item label="企业名称">
            <el-input v-model="keyword" placeholder="输入企业名称关键字" clearable style="width:220px" @keyup.enter.native="loadData"></el-input>
          <el-form-item :label="keywordLabel">
            <el-input v-model="keyword" :placeholder="keywordPlaceholder" clearable style="width:220px" @keyup.enter.native="loadData"></el-input>
          </el-form-item>
          <el-form-item>
            <el-button type="primary" @click="loadData">查询</el-button>
          </el-form-item>
          <el-form-item label="仅显示已填写">
            <el-switch v-model="hasExplanation" @change="onFilterChange"></el-switch>
          </el-form-item>
          <el-form-item>
            <span style="color:#909399;font-size:12px">共 {{ total }} æ¡è§£é‡Š</span>
            <span style="color:#909399;font-size:12px">共 {{ total }} æ¡è®°å½•<template v-if="hasExplanation">（已填写解释）</template></span>
          </el-form-item>
        </el-form>
        <div class="table-area">
        <el-table :data="records" border v-loading="loading" size="small" style="width:100%" height="100%">
          <el-table-column prop="reportPeriod" label="报表期" width="100"></el-table-column>
          <el-table-column prop="regionCode" label="所属地区" width="100"></el-table-column>
          <el-table-column prop="enterpriseCode" label="企业代码" min-width="140" show-overflow-tooltip></el-table-column>
          <el-table-column prop="enterpriseName" label="企业名称" min-width="200" show-overflow-tooltip></el-table-column>
          <el-table-column prop="vehicleTotal" label="车辆数" width="90"></el-table-column>
          <el-table-column prop="tonsTotal" label="吨位" width="100"></el-table-column>
          <el-table-column prop="freightTotal" label="货运量" width="110"></el-table-column>
          <el-table-column prop="turnoverTotal" label="周转量" width="120"></el-table-column>
          <el-table-column prop="avgDistance" label="平均运距" width="100"></el-table-column>
          <el-table-column prop="verifyExplanation" label="企业解释" min-width="280" show-overflow-tooltip></el-table-column>
          <el-table-column label="操作" width="100" fixed="right">
        <el-table :data="records" border v-loading="loading" size="mini" :row-style="{ height: '32px' }" style="width:100%" height="100%">
          <el-table-column v-for="col in columns" :key="col.prop" v-bind="col">
            <template slot-scope="scope">
              <template v-if="col.prop === 'verifyExplanation'">
                <span v-if="scope.row.verifyExplanation" class="expl-text">{{ scope.row.verifyExplanation }}</span>
                <el-tag v-else size="mini" type="warning" effect="plain">未填写</el-tag>
              </template>
              <span v-else>{{ scope.row[col.prop] }}</span>
            </template>
          </el-table-column>
          <el-table-column label="操作" width="110" fixed="right">
            <template slot-scope="scope">
              <el-button size="mini" type="primary" @click="analyze(scope.row)">AI åˆ†æž</el-button>
            </template>
@@ -64,22 +74,87 @@
import AppHeader from '@/components/AppHeader.vue'
import api from '@/api'
import AiChatDialog from '@/components/AiChatDialog'
const COLS = {
  H2032: [
    { prop: 'reportPeriod', label: '报表期', width: 100 },
    { prop: 'regionCode', label: '所属地区', width: 100 },
    { prop: 'enterpriseCode', label: '企业代码', minWidth: 140, showOverflowTooltip: true },
    { prop: 'enterpriseName', label: '企业名称', minWidth: 200, showOverflowTooltip: true },
    { prop: 'vehicleTotal', label: '车辆数', width: 90 },
    { prop: 'tonsTotal', label: '吨位', width: 100 },
    { prop: 'freightTotal', label: '货运量(吨)', width: 110 },
    { prop: 'turnoverTotal', label: '周转量(吨公里)', width: 130 },
    { prop: 'avgDistance', label: '平均运距(公里)', width: 120 },
    { prop: 'verifyExplanation', label: '企业解释', minWidth: 260, showOverflowTooltip: true }
  ],
  H2031: [
    { prop: 'reportPeriod', label: '报表期', width: 100 },
    { prop: 'regionCode', label: '所属地区', width: 100 },
    { prop: 'enterpriseCode', label: '企业代码', minWidth: 140, showOverflowTooltip: true },
    { prop: 'enterpriseName', label: '企业名称', minWidth: 200, showOverflowTooltip: true },
    { prop: 'vehicleTotal', label: '车辆数', width: 90 },
    { prop: 'seatTotal', label: '载客位数', width: 100 },
    { prop: 'passengerTotal', label: '客运量(万人)', width: 110 },
    { prop: 'turnoverTotal', label: '周转量(万人公里)', width: 130 },
    { prop: 'avgDistance', label: '平均运距(公里)', width: 120 },
    { prop: 'verifyExplanation', label: '企业解释', minWidth: 260, showOverflowTooltip: true }
  ],
  CITY_BUS: [
    { prop: 'reportPeriod', label: '报表期', width: 100 },
    { prop: 'regionCode', label: '所属地区', width: 100 },
    { prop: 'city', label: '市州', width: 100 },
    { prop: 'enterpriseName', label: '企业名称', minWidth: 220, showOverflowTooltip: true },
    { prop: 'opVehicles', label: '运营车数', width: 90 },
    { prop: 'passengerVolume', label: '客运量(万人次)', width: 120 },
    { prop: 'turnover', label: '周转量(万人公里)', width: 130 },
    { prop: 'avgDistance', label: '平均运距(公里)', width: 120 },
    { prop: 'verifyExplanation', label: '企业解释', minWidth: 260, showOverflowTooltip: true }
  ],
  CITY_TAXI: [
    { prop: 'reportPeriod', label: '报表期', width: 100 },
    { prop: 'regionCode', label: '所属地区', width: 100 },
    { prop: 'city', label: '市州', width: 110 },
    { prop: 'tripTotal', label: '载客车次总数', width: 110 },
    { prop: 'passengerVolume', label: '客运量(万人次)', width: 120 },
    { prop: 'turnover', label: '周转量(万人公里)', width: 130 },
    { prop: 'opVehicles', label: '运营车辆数', width: 100 },
    { prop: 'avgDistance', label: '平均运距(公里)', width: 120 },
    { prop: 'verifyExplanation', label: '企业解释', minWidth: 260, showOverflowTooltip: true }
  ]
}
const TABLE_NAME = {
  H2032: 'h2032_enterprise_monthly',
  H2031: 'h2031_enterprise_monthly',
  CITY_BUS: 'city_bus_monthly',
  CITY_TAXI: 'city_taxi_monthly'
}
export default {
  components: { AppHeader },
  name: 'ExplainReview',
  components: { AppHeader, AiChatDialog },
  components: { AiChatDialog },
  data() {
    return {
      period: '', keyword: '', page: 1, size: 20, total: 0, records: [], loading: false,
      reportType: 'H2032',
      period: '', keyword: '', hasExplanation: false, page: 1, size: 20, total: 0, records: [], loading: false,
      chatVisible: false, chatContext: {}
    }
  },
  computed: {
    columns() { return COLS[this.reportType] || COLS.H2032 },
    keywordLabel() { return this.reportType === 'CITY_TAXI' ? '市州名称' : '企业名称' },
    keywordPlaceholder() { return this.reportType === 'CITY_TAXI' ? '输入市州名称关键字' : '输入企业名称关键字' }
  },
  methods: {
    onTypeChange() { this.page = 1; this.loadData() },
    onFilterChange() { this.page = 1; this.loadData() },
    loadData() {
      this.loading = true
      api.get('/explain/list', {
        params: {
          reportType: this.reportType,
          period: this.period || undefined,
          keyword: this.keyword || undefined,
          hasExplanation: this.hasExplanation || undefined,
          page: this.page,
          size: this.size
        }
@@ -103,16 +178,26 @@
      this.chatContext = {
        reportId: row.id,
        reportPeriod: row.reportPeriod || this.period,
        enterpriseName: row.enterpriseName || '',
        verifyExplanation: explanation
        enterpriseName: row.enterpriseName || row.city || '',
        verifyExplanation: explanation,
        reportType: this.reportType,
        tableName: TABLE_NAME[this.reportType] || ''
      }
      this.chatVisible = true
    }
  },
  mounted() {
    const q = this.$route.query
    if (q.reportType && COLS[q.reportType]) this.reportType = q.reportType
    if (q.period) this.period = q.period
    if (q.keyword) this.keyword = q.keyword
    this.loadData()
  }
}
</script>
<style scoped>
.el-header { background: #409EFF; color: white; line-height: 60px; font-size: 18px; }
.el-table td { padding: 3px 0; }
.el-table th { padding: 4px 0; }
.expl-text { display: inline-block; max-height: 62px; overflow-y: auto; white-space: pre-wrap; word-break: break-all; line-height: 1.4; }
</style>

 traffic-audit-web/src/views/Login.vue

@@ -69,6 +69,8 @@
          if (d.code === 200) {
            localStorage.setItem('token', d.data.token)
            localStorage.setItem('username', d.data.username)
            localStorage.setItem('realName', d.data.realName || '')
            localStorage.setItem('modules', d.data.modules || '')
            this.$message.success('登录成功')
            this.$router.push('/dashboard')
          } else if (d.code === 401) {

 traffic-audit-web/src/views/ReportExport.vue

@@ -3,7 +3,7 @@
    <app-header title="交通统计报表审核系统 - æŠ¥è¡¨ç”Ÿæˆ"></app-header>
    <el-container>
      <el-aside width="200px">
        <el-menu router default-active="/report">
        <el-menu router :default-active="activeMenu">
          <el-menu-item index="/dashboard">工作台</el-menu-item>
          <el-menu-item index="/import">数据导入</el-menu-item>
          <el-menu-item index="/data">数据查看</el-menu-item>
@@ -16,68 +16,472 @@
      </el-aside>
      <el-main>
        <div class="page-scroll">
          <!-- ç¬¬ä¸€è¡Œï¼šæ ‡é¢˜ + æ›´æ–°æ—¶é—´ -->
          <div class="topbar">
        <h3>生成统计报表</h3>
        <el-card style="max-width:640px">
          <el-form label-width="100px">
            <el-form-item label="报表期">
              <el-date-picker v-model="period" type="month" placeholder="选择月份" value-format="yyyy-MM" style="width:100%"></el-date-picker>
            </el-form-item>
            <el-form-item>
              <el-button type="primary" @click="exportReport('cityDetail')" :loading="loading === 'cityDetail'">生成_货运量分市州明细</el-button>
            </el-form-item>
            <el-form-item>
              <el-button type="primary" @click="exportReport('freightRank')" :loading="loading === 'freightRank'">生成_货运量排名</el-button>
              <el-button type="primary" @click="exportReport('turnoverRank')" :loading="loading === 'turnoverRank'">生成_周转量排名</el-button>
            </el-form-item>
          </el-form>
        </el-card>
        <el-alert
          title="提示：报表由系统根据已导入数据自动计算生成。货运量：合计来自模板_货运量周转量（左半1-N月）、规上来自H203-2月报、规下=合计-规上；周转量来自规上规下拆分表。"
          type="info" style="margin-top:15px" :closable="false"></el-alert>
            <div class="topbar-right">
              <span v-if="myModules.length" class="focus-user">{{ realName || username }}：负责 {{ myModules.map(moduleTitle).join('、') }}</span>
              <span class="update-time">更新时间：{{ updatedAt }}</span>
        </div>
          </div>

          <!-- ç¬¬äºŒè¡Œï¼šæŠ¥è¡¨ç±»åž‹ Tab（货运 / æ—…客 / æŠ•èµ„ / èƒ½è€— / åŸŽå¸‚客运） -->
          <el-tabs v-model="activeKey" class="module-tabs">
            <el-tab-pane v-for="m in modules" :key="m.key" :name="m.key">
              <span slot="label">{{ m.title }}<el-tag v-if="m.tag" size="mini" :type="m.tagType || 'info'" style="margin-left:6px">{{ m.tag }}</el-tag></span>
            </el-tab-pane>
          </el-tabs>

          <!-- ç¬¬ä¸‰è¡Œï¼šæŸ¥è¯¢æ¡ä»¶åŒºï¼ˆå‘¨æœŸ + æœˆä»½ + æŸ¥è¯¢ï¼‰ -->
          <section class="query-panel">
            <span class="ctrl-label">周期</span>
            <el-radio-group v-model="cycle" size="small" @change="onCycleChange">
              <el-radio-button v-for="opt in cycleOptions" :key="opt.value" :label="opt.value">{{ opt.label }}</el-radio-button>
            </el-radio-group>
            <span class="ctrl-label">{{ cycle === 'year' ? '年份' : '月份' }}</span>
            <el-select v-model="period" size="small" style="width:190px" :placeholder="periodPlaceholder" @change="onPeriodChange">
              <el-option-group v-for="grp in periodGroups" :key="grp.label" :label="grp.label">
                <el-option v-for="opt in grp.options" :key="opt.value" :label="opt.label" :value="opt.value"></el-option>
              </el-option-group>
            </el-select>
            <el-button type="primary" size="small" icon="el-icon-search" @click="doQuery">查询</el-button>
          </section>

          <!-- ç¬¬å››è¡Œï¼šæŠ¥è¡¨åˆ—表 -->
          <section class="module-panel">
            <div class="panel-head">
              <div class="panel-title">报表列表<span class="muted">（{{ curModule.title }}）</span></div>
              <div class="panel-controls">
                <el-checkbox :value="allChecked" @change="toggleAll">全选</el-checkbox>
                <span class="checked-count">已选 {{ curModule.checked.length }} å¼ </span>
                <el-button size="small" icon="el-icon-view" :disabled="!curModule.checked.length" @click="previewChecked()">批量预览</el-button>
                <el-button size="small" type="primary" icon="el-icon-download" :disabled="!curModule.checked.length" @click="exportChecked()">批量导出</el-button>
              </div>
            </div>
            <el-table :data="curModule.items" size="mini" class="report-table">
              <el-table-column width="44">
                <template slot-scope="{ row }">
                  <el-checkbox :value="curModule.checked.indexOf(row.key) >= 0" @change="toggleChecked(row)"></el-checkbox>
                </template>
              </el-table-column>
              <el-table-column label="报表名称" prop="label" min-width="220"></el-table-column>
              <el-table-column label="数据状态" width="180">
                <template slot-scope="{ row }">
                  <el-tag v-if="row.status === 'ready'" size="mini" type="success">数据就绪</el-tag>
                  <el-tag v-else-if="row.status === 'unaudited'" size="mini" type="warning">未审核</el-tag>
                  <el-tag v-else-if="row.status === 'missing'" size="mini" type="danger">缺数据</el-tag>
                  <el-tag v-else size="mini" type="info">—</el-tag>
                  <div v-if="row.statusNote" class="status-note">{{ row.statusNote }}</div>
                </template>
              </el-table-column>
              <el-table-column label="备注" min-width="190">
                <template slot-scope="{ row }">
                  <span class="note-text">{{ noteOf(row.key) || '点击图标添加备注' }}</span>
                  <el-button size="mini" type="text" icon="el-icon-edit" title="编辑备注" @click="openNoteDialog(row)"></el-button>
                </template>
              </el-table-column>
              <el-table-column label="操作" width="170" align="right">
                <template slot-scope="{ row }">
                  <el-button size="mini" icon="el-icon-view" @click="previewOne(row)">预览</el-button>
                  <el-button size="mini" type="primary" icon="el-icon-download" @click="exportOne(row)">导出</el-button>
                </template>
              </el-table-column>
            </el-table>
            <div class="panel-footer">共 {{ curModule.items.length }} å¼ æŠ¥è¡¨</div>
          </section>

          <el-alert title="使用提示" type="info" style="margin-top:15px" :closable="false">
            <div class="tip-text">
              <p>1. é€‰æ‹©æŠ¥è¡¨ç±»åž‹ Tab、周期与月份后点击「查询」，列表会显示每张报表的数据状态（数据就绪 / ç¼ºæ•°æ® / æœªå®¡æ ¸ï¼‰ã€‚</p>
              <p>2. æ•°æ®æ ¡éªŒä¸Žå®¡æ ¸è¯·åˆ°ã€Œå®¡æ ¸ç»“果」页查看，规则可在「规则管理」页配置。</p>
              <p>3. å•å¼ å¯ç›´æŽ¥ç‚¹ã€Œé¢„览 / å¯¼å‡ºã€ï¼›å¤šå¼ å¯å‹¾é€‰åŽã€Œæ‰¹é‡é¢„览 / æ‰¹é‡å¯¼å‡ºã€ï¼Œå¤šå¼ å¯¼å‡ºè‡ªåŠ¨æ‰“包为 zip。</p>
              <p>4. æœˆæŠ¥ï¼šé€‰ 2026-07 ç”Ÿæˆ 1~7 æœˆæ•°æ®ï¼›å¹´æŠ¥ï¼šé€‰å¹´ä»½ç”Ÿæˆå…¨å¹´ 1~12 æœˆ + ä¸Šå¹´åŒæ¯”。</p>
            </div>
          </el-alert>
        </div>
        <el-dialog :title="'预览数据 - ' + previewModule + '（' + previewPeriod + '）'" :visible.sync="previewVisible" width="760px">
          <div class="preview-body">
            <div v-for="it in previewItems" :key="it.key" class="preview-item">
              <div class="preview-head">
                <span class="preview-name">{{ it.label }}</span>
                <span class="preview-rows">共 {{ it.rowCount || 0 }} è¡Œ</span>
              </div>
              <div class="preview-coverage">
                <span class="cov-label">月度覆盖：</span>
                <span :class="it.ready ? 'cov-ok' : 'cov-bad'">{{ coverageText(it) }}</span>
                <span v-if="!it.ready" class="cov-bad" style="margin-left:10px">{{ it.note }}</span>
                <span v-if="it.ready && it.audited === false" class="cov-bad" style="margin-left:10px">未审核</span>
              </div>
              <table class="preview-summary" v-if="it.summary && it.summary.length">
                <tbody>
                  <tr v-for="(s, i) in it.summary" :key="i">
                    <td>{{ s.name }}</td>
                    <td><span v-if="s.value === null || s.value === ''" class="cell-empty">（空）</span>{{ fmtVal(s.value) }}</td>
                  </tr>
                </tbody>
              </table>
              <div class="preview-problems" v-if="it.problems && it.problems.length">
                <div v-for="(p, i) in it.problems" :key="i" class="prob-item">· {{ p }}</div>
              </div>
              <div class="preview-ok" v-else-if="it.ready">数据完整，可正常生成</div>
            </div>
          </div>
          <span slot="footer">
            <el-button size="small" @click="previewVisible = false">关闭</el-button>
          </span>
        </el-dialog>

        <!-- å¤‡æ³¨ç¼–辑弹窗 -->
        <el-dialog title="编辑备注" :visible.sync="noteDialogVisible" width="480px">
          <el-input v-model="noteDraft" type="textarea" :rows="4" placeholder="填写该报表的备注说明（保存后本地记忆）"></el-input>
          <span slot="footer">
            <el-button size="small" @click="noteDialogVisible = false">取消</el-button>
            <el-button size="small" type="primary" @click="saveNote">保存</el-button>
          </span>
        </el-dialog>
      </el-main>
    </el-container>
  </el-container>
</template>

<script>
import AppHeader from '@/components/AppHeader.vue'
import api from '@/api'

export default {
  components: { AppHeader },
  name: 'ReportExport',
  data() {
    return { period: '', loading: '' }
    return {
      loading: '',
      activeMenu: '/report',
      activeKey: '',
      updatedAt: '',
      // æŸ¥è¯¢æ¡ä»¶ï¼šcycle å‘¨æœŸï¼ˆmonth æœˆæŠ¥ / quarter å­£æŠ¥ / year å¹´æŠ¥ï¼‰ï¼Œperiod æŠ¥è¡¨æœŸï¼ˆæœˆä»½ yyyy-MM æˆ–年份 yyyy）
      cycle: 'month',
      period: '',
      // é¢„览弹窗
      previewVisible: false,
      previewItems: [],
      previewModule: '',
      previewPeriod: '',
      // å¤‡æ³¨ç¼–辑弹窗
      noteDialogVisible: false,
      noteEditingKey: '',
      noteDraft: '',
      modules: [
        {
          key: 'freight', title: '货运报表', items: [
            { key: 'cityDetail', label: '货运量分市州明细', fileName: '生成_货运量分市州明细.xlsx', status: null, statusNote: '' },
            { key: 'freightRank', label: '货运量排名', fileName: '生成_货运量排名.xlsx', status: null, statusNote: '' },
            { key: 'turnoverRank', label: '周转量排名', fileName: '生成_周转量排名.xlsx', status: null, statusNote: '' }
          ], checked: []
  },
  methods: {
    exportReport(type) {
      if (!this.period) { this.$message.warning('请选择报表期'); return }
      this.loading = type
      const token = localStorage.getItem('token') || ''
      api.get('/report/export/' + type, { params: { period: this.period }, responseType: 'blob' })
        {
          key: 'passenger', title: '旅客报表', items: [
            { key: 'passengerCityDetail', label: '公路旅客分市州', fileName: '生成_公路旅客分市州.xlsx', status: null, statusNote: '' },
            { key: 'passengerMidDetail', label: '中口径明细', fileName: '生成_公路旅客中口径明细.xlsx', status: null, statusNote: '' },
            { key: 'passengerMidRank', label: '中口径排名', fileName: '生成_公路旅客中口径排名.xlsx', status: null, statusNote: '' },
            { key: 'passengerMidAnalysis', label: '中口径分析', fileName: '生成_公路旅客中口径分析.xlsx', status: null, statusNote: '' }
          ], checked: []
        },        {
          key: 'cityPassenger', title: '城市客运报表', tag: '公交/出租/轨道轮渡/汇总', tagType: 'success', items: [
            { key: 'cityBusDetail', label: '城市公交客运量分市州明细', fileName: '生成_城市公交客运量分市州明细.xlsx', status: null, statusNote: '' },
            { key: 'cityTaxiDetail', label: '巡游出租客运量分市州明细', fileName: '生成_巡游出租客运量分市州明细.xlsx', status: null, statusNote: '' },
            { key: 'cityRailFerryDetail', label: '轨道轮渡客运量分市州明细', fileName: '生成_轨道轮渡客运量分市州明细.xlsx', status: null, statusNote: '' },
            { key: 'cityPassengerCitySum', label: '城市客运客运量分市州累计', fileName: '生成_城市客运客运量分市州累计.xlsx', status: null, statusNote: '' },
            { key: 'cityPassengerDetailSum', label: '城市客运各市州明细表', fileName: '生成_城市客运各市州明细表.xlsx', status: null, statusNote: '' },
            { key: 'cityPassengerSummary', label: '城市客运汇总', fileName: '生成_城市客运汇总.xlsx', status: null, statusNote: '' }
          ], checked: []
        },
        {
          key: 'invest', title: '投资报表', items: [
            { key: 'investPlan', label: '全省预安排计划进度汇总', fileName: '生成_全省预安排计划进度情况汇总.xls', status: null, statusNote: '' },
            { key: 'investFiveYearLogistics', label: '十五五规划物流项目进展', fileName: '生成_十五五规划物流项目进展情况.xls', status: null, statusNote: '' },
            { key: 'investBillion', label: '亿元投资项目', fileName: '生成_湖北省（客货站场）亿元投资项目.xls', status: null, statusNote: '' },
            { key: 'investCounty', label: '经济强县项目投资统计', fileName: '生成_经济强县交通物流基础设施投资统计报表.xls', status: null, statusNote: '' }
          ], checked: []
        },
        {
          key: 'energy', title: '能耗报表', items: [
            { key: 'energySummary', label: '能运汇总表', fileName: '生成_能运汇总表.xlsx', status: null, statusNote: '' }
          ], checked: []
        }
      ]
    }
  },
  computed: {
    username() { return localStorage.getItem('username') || '' },
    realName() { return localStorage.getItem('realName') || '' },
    myModules() {
      const s = localStorage.getItem('modules')
      if (!s) return []
      return s.split(',').filter(Boolean)
    },
    curModule() {
      return this.modules.find(m => m.key === this.activeKey) || this.modules[0]
    },
    allChecked() {
      const m = this.curModule
      return m.items.length > 0 && m.checked.length === m.items.length
    },
    // å‘¨æœŸé€‰é¡¹ï¼šèƒ½è€—为季报（季度末月），其余为月报 / å¹´æŠ¥
    cycleOptions() {
      if (this.activeKey === 'energy') return [{ label: '季报', value: 'quarter' }]
      return [{ label: '月报', value: 'month' }, { label: '年报', value: 'year' }]
    },
    periodPlaceholder() {
      return this.cycle === 'year' ? '选择年份' : '选择月份'
    },
    // æŠ¥è¡¨æœŸä¸‹æ‹‰åˆ†ç»„：年报按年份；月报/季报按年分组列 1-12 æœˆï¼ˆèƒ½è€—只列季度末月）
    periodGroups() {
      const year = new Date().getFullYear()
      const years = [year - 1, year, year + 1]
      if (this.cycle === 'year') {
        return [{ label: '选择年份', options: years.map(y => ({ label: y + 'å¹´', value: String(y) })) }]
      }
      const months = this.activeKey === 'energy' ? [3, 6, 9, 12] : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
      return years.map(y => ({
        label: y + 'å¹´' + (this.activeKey === 'energy' ? '（季度末月）' : ''),
        options: months.map(mo => ({ label: y + 'å¹´' + mo + '月', value: y + '-' + String(mo).padStart(2, '0') }))
      }))
    },
  },
  watch: {
    activeKey() {
      this.ensureCycle()
      this.refreshAll()
    }
  },
  created() {
    const mine = this.myModules.filter(k => this.modules.some(m => m.key === k))
    this.activeKey = (mine.length ? mine : this.modules.map(m => m.key))[0]
    this.ensureCycle()
    this.refreshAll()
  },  methods: {
    moduleTitle(key) {
      const m = this.modules.find(x => x.key === key)
      return m ? m.title : key
    },
    logout() {
      localStorage.removeItem('token'); localStorage.removeItem('username'); localStorage.removeItem('realName'); localStorage.removeItem('modules')
      this.$router.push('/login')
    },
    // ==================== æŸ¥è¯¢æ¡ä»¶ä¸ŽçŠ¶æ€åˆ·æ–° ====================
    buildParams() {
      const p = { period: this.period }
      p.mode = this.cycle === 'year' ? 'year' : 'month'
      return p
    },
    // å‘¨æœŸä¸ŽæŠ¥è¡¨æœŸåŒ¹é…ï¼šåˆ‡æ¢å‘¨æœŸåŽæ¸…掉不匹配的旧值
    normalizePeriod() {
      const isYear = /^\d{4}$/.test(this.period || '')
      const isMonth = /^\d{4}-\d{2}$/.test(this.period || '')
      if (this.cycle === 'year' && isMonth) this.period = ''
      if (this.cycle !== 'year' && isYear) this.period = ''
    },
    ensureCycle() {
      const allowed = this.cycleOptions.map(o => o.value)
      if (!allowed.includes(this.cycle)) this.cycle = allowed[0]
      this.normalizePeriod()
    },
    onCycleChange() {
      this.normalizePeriod()
      this.refreshAll()
    },
    onPeriodChange() {
      this.refreshAll()
    },
    doQuery() {
      if (!this.period) { this.$message.warning('请先选择周期和月份'); return }
      this.refreshAll()
    },
    refreshAll() {
      this.updatedAt = new Date().toLocaleString('zh-CN', { hour12: false })
      this.refreshStatus()
    },
    refreshStatus() {
      const m = this.curModule
      if (!m || !this.period) return
      const params = Object.assign(this.buildParams(), { types: m.items.map(i => i.key).join(',') })
      api.get('/report/ready', { params })
        .then(res => {
          const blob = new Blob([res], { type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' })
          const list = (res && res.data && res.data.items) || []
          list.forEach(r => {
            const it = m.items.find(x => x.key === r.key)
            if (!it) return
            if (!r.ready) { it.status = 'missing'; it.statusNote = r.note || '缺数据' }
            else if (r.audited === false) { it.status = 'unaudited'; it.statusNote = '尚未审核通过' }
            else { it.status = 'ready'; it.statusNote = '' }
          })
        })
        .catch(() => {})
    },
    noteOf(key) {
      return localStorage.getItem('report_note_' + key) || ''
    },
    openNoteDialog(row) {
      this.noteEditingKey = row.key
      this.noteDraft = this.noteOf(row.key)
      this.noteDialogVisible = true
    },
    saveNote() {
      localStorage.setItem('report_note_' + this.noteEditingKey, this.noteDraft.trim())
      this.noteDialogVisible = false
      this.$message.success('备注已保存')
    },
    // ==================== å‹¾é€‰ / é¢„览 / å¯¼å‡º ====================
    toggleChecked(row) {
      const checked = this.curModule.checked
      const i = checked.indexOf(row.key)
      if (i >= 0) checked.splice(i, 1)
      else checked.push(row.key)
    },
    toggleAll(v) {
      this.curModule.checked = v ? this.curModule.items.map(i => i.key) : []
    },
    exportOne(item) { this.exportChecked([item]) },
    previewOne(item) { this.previewChecked([item]) },
    previewChecked(itemList) {
      const m = this.curModule
      if (!this.period) { this.$message.warning('请先选择周期和月份'); return }
      const items = itemList || m.items.filter(i => m.checked.includes(i.key))
      if (!items.length) { this.$message.warning('请选择要预览的报表'); return }
      this.loading = 'preview-' + m.key
      const params = Object.assign(this.buildParams(), { types: items.map(i => i.key).join(',') })
      api.get('/report/preview', { params })
        .then(res => {
          const list = (res && res.data && res.data.items) || []
          this.previewItems = list.map(it => {
            const item = items.find(x => x.key === it.key)
            return Object.assign({}, it, { label: item ? item.label : it.key })
          })
          this.previewModule = m.title
          this.previewPeriod = this.period
          this.previewVisible = true
          this.loading = ''
        })
        .catch(err => this.failWith(err))
    },
    fmtVal(v) {
      if (v === null || v === undefined || v === '') return '—'
      if (typeof v === 'number') {
        if (Number.isInteger(v)) return String(v)
        return v.toFixed(4).replace(/\.?0+$/, '')
      }
      return String(v)
    },
    coverageText(it) {
      const cov = it.monthCoverage || []
      if (!cov.length) return '无数据'
      const continuous = cov.length === cov[cov.length - 1]
      if (continuous) return '1~' + cov[cov.length - 1] + '月均有数据'
      return cov.map(x => x + '月').join('、') + ' æœ‰æ•°æ®'
    },
    exportChecked(itemList) {
      const m = this.curModule
      if (!this.period) { this.$message.warning('请先选择周期和月份'); return }
      const items = itemList || m.items.filter(i => m.checked.includes(i.key))
      if (!items.length) { this.$message.warning('请选择要导出的报表'); return }
      this.loading = 'gen-' + m.key
      const params = this.buildParams()
      const doExport = () => {
        if (items.length === 1) {
          api.get('/report/export/' + items[0].key, { params, responseType: 'blob' })
            .then(res => { this.downloadBlob(res, items[0].fileName); this.$message.success('报表导出成功'); this.loading = '' })
            .catch(err => this.failWith(err))
          return
        }
        const zipParams = Object.assign({}, params, { types: items.map(i => i.key).join(',') })
        api.get('/report/export/selected', { params: zipParams, responseType: 'blob' })
          .then(res => { this.downloadBlob(res, '生成_所选报表_' + this.period + '.zip'); this.$message.success('已导出 ' + items.length + ' å¼ æŠ¥è¡¨ï¼ˆzip）'); this.loading = '' })
          .catch(err => this.failWith(err))
      }
      const readyParams = Object.assign({}, params, { types: items.map(i => i.key).join(',') })
      api.get('/report/ready', { params: readyParams })
        .then(rd => {
          const list = (rd && rd.data && rd.data.items) || []
          const missing = list.filter(i => !i.ready)
          const unaudited = list.filter(i => i.ready && i.audited === false)
          const lines = []
          missing.forEach(i => {
            const it = items.find(x => x.key === i.key)
            lines.push('【缺数据】' + (it ? it.label : i.key) + '（' + i.note + '）')
          })
          unaudited.forEach(i => {
            const it = items.find(x => x.key === i.key)
            lines.push('【未审核】' + (it ? it.label : i.key))
          })
          if (!lines.length) { doExport(); return }
          this.$confirm('以下报表请注意：\n' + lines.join('\n') + '\n\n仍要导出吗？', '导出前提示', {
            confirmButtonText: '仍要导出', cancelButtonText: '取消', type: 'warning'
          }).then(() => doExport()).catch(() => { this.loading = '' })
        })
        .catch(() => doExport())
    },
    failWith(err) {
      let msg = ''
      const d = err && err.response && err.response.data
      if (d && typeof d === 'object' && d.message) msg = d.message
      this.$message.error('导出失败：' + (msg || '请确认已导入对应数据，或查看后端日志'))
      this.loading = ''
    },
    downloadBlob(res, fileName) {
      const isZip = /\.zip$/.test(fileName)
      const isXls = /\.xls$/.test(fileName)
      const blob = new Blob([res], { type: isZip ? 'application/zip' : (isXls ? 'application/vnd.ms-excel' : 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet') })
          const url = window.URL.createObjectURL(blob)
          const a = document.createElement('a')
          a.href = url
          a.download = this.fileName(type)
      a.download = fileName
          document.body.appendChild(a)
          a.click()
          window.URL.revokeObjectURL(url)
          this.$message.success('报表生成成功')
        })
        .catch(() => { this.$message.error('报表生成失败，请确认已导入对应数据') })
        .finally(() => { this.loading = '' })
    },
    fileName(type) {
      const map = {
        cityDetail: '生成_货运量分市州明细.xlsx',
        freightRank: '生成_货运量排名.xlsx',
        turnoverRank: '生成_周转量排名.xlsx'
      }
      return map[type] || 'report.xlsx'
    }
  }
}
</script>
<style scoped>
</script><style scoped>
.el-header { background: #409EFF; color: white; line-height: 60px; font-size: 18px; }
.page-scroll { max-width: 1200px; }
.topbar { display: flex; align-items: center; justify-content: space-between; margin-bottom: 12px; }
.topbar h3 { margin: 0; }
.topbar-right { display: flex; align-items: center; gap: 12px; font-size: 13px; color: #606266; }
.update-time { font-size: 12px; color: #909399; }
.module-tabs { margin-bottom: 6px; }
.query-panel { background: #fff; border: 1px solid #ebeef5; border-radius: 6px; padding: 12px 16px; margin-bottom: 12px; display: flex; align-items: center; gap: 12px; flex-wrap: wrap; }
.data-card { background: #fff; border: 1px solid #ebeef5; border-radius: 6px; padding: 14px 16px; margin-bottom: 12px; }
.card-title { font-size: 15px; font-weight: 600; color: #303133; margin-bottom: 10px; display: flex; align-items: center; gap: 8px; }
.muted { font-size: 12px; color: #909399; font-weight: 400; }
.module-panel { background: #fff; border: 1px solid #ebeef5; border-radius: 6px; padding: 14px 16px; }
.ctrl-label { font-size: 13px; color: #606266; }
.panel-head { display: flex; align-items: center; justify-content: space-between; flex-wrap: wrap; gap: 10px; margin-bottom: 12px; }
.panel-title { font-size: 16px; font-weight: 600; color: #303133; display: flex; align-items: center; gap: 6px; }
.panel-controls { display: flex; align-items: center; gap: 10px; }
.report-table { width: 100%; }
.checked-count { font-size: 12px; color: #909399; }
.panel-footer { margin-top: 10px; font-size: 12px; color: #909399; text-align: right; }
.status-note { font-size: 11px; color: #F56C6C; margin-top: 2px; line-height: 1.4; }
.note-text { font-size: 12px; color: #606266; margin-right: 4px; }
.spacer { flex: 1; }
.preview-body { max-height: 68vh; overflow-y: auto; }
.preview-item { border: 1px solid #ebeef5; border-radius: 6px; padding: 12px 14px; margin-bottom: 12px; }
.preview-head { display: flex; align-items: center; margin-bottom: 8px; }
.preview-name { font-weight: 600; font-size: 15px; margin-right: 10px; }
.preview-rows { margin-left: auto; color: #909399; font-size: 12px; }
.preview-coverage { font-size: 13px; margin-bottom: 8px; }
.cov-ok { color: #67C23A; }
.cov-bad { color: #F56C6C; }
.cov-label { color: #909399; }
.preview-summary { width: 100%; border-collapse: collapse; font-size: 13px; margin-bottom: 8px; }
.preview-summary th, .preview-summary td { border: 1px solid #ebeef5; padding: 4px 8px; text-align: left; }
.preview-summary th { background: #f5f7fa; }
.preview-summary .cell-empty { color: #F56C6C; }
.preview-problems { font-size: 13px; color: #F56C6C; }
.preview-problems .prob-item { margin: 2px 0; }
.preview-ok { font-size: 13px; color: #67C23A; }
.tip-text { font-size: 13px; line-height: 1.7; }
.tip-text p { margin: 2px 0; }
@media (max-width: 900px) {
  .panel-head { flex-direction: column; align-items: flex-start; }
}
</style>

 traffic-audit-web/src/views/RuleManage.vue

@@ -1,2 +1,114 @@
<template><div>规则管理</div></template>
<script>export default { name: 'RuleManage' }</script>
<template>
  <el-container>
    <el-header>交通统计报表审核系统 - è§„则管理</el-header>
    <el-container>
      <el-aside width="200px">
        <el-menu router default-active="/rules">
          <el-menu-item index="/dashboard">工作台</el-menu-item>
          <el-menu-item index="/import">数据导入</el-menu-item>
          <el-menu-item index="/data">数据查看</el-menu-item>
          <el-menu-item index="/explain">企业解释</el-menu-item>
          <el-menu-item index="/audit">审核结果</el-menu-item>
          <el-menu-item index="/report">报表生成</el-menu-item>
          <el-menu-item index="/rules">规则管理</el-menu-item>
          <el-menu-item index="/users">用户管理</el-menu-item>
          <el-menu-item index="/login" @click="logout">退出登录</el-menu-item>
</el-menu>
      </el-aside>
      <el-main>
        <h3>审核规则管理</h3>
        <el-form :inline="true">
          <el-form-item label="报表类型">
            <el-radio-group v-model="reportType" @change="loadRules">
              <el-radio label="H2032">货运月报</el-radio>
              <el-radio label="H2031">旅客月报</el-radio>
              <el-radio label="CITY_BUS">城市公交月报</el-radio>
              <el-radio label="CITY_TAXI">巡游出租月报</el-radio>
              <el-radio label="INVEST">投资月报</el-radio>
              <el-radio label="H204">能耗季报</el-radio>
            
            
            
            </el-radio-group>
          </el-form-item>
          <el-form-item>
            <el-button type="primary" @click="loadRules" :loading="loading">刷新</el-button>
          </el-form-item>
        </el-form>
        <div class="table-area">
        <el-table :data="rules" border v-loading="loading" size="small" style="width:100%" height="100%">
          <el-table-column prop="ruleCode" label="规则编码" width="120"></el-table-column>
          <el-table-column prop="ruleName" label="规则名称" min-width="180"></el-table-column>
          <el-table-column prop="description" label="规则说明" min-width="260" show-overflow-tooltip></el-table-column>
          <el-table-column label="比较方式" width="130">
            <template slot-scope="scope">{{ typeLabel(scope.row.compareType) }}</template>
          </el-table-column>
          <el-table-column label="阈值" width="130">
            <template slot-scope="scope">
              <el-input v-model="scope.row.threshold" size="mini" placeholder="阈值" @change="saveThreshold(scope.row)"></el-input>
            </template>
          </el-table-column>
          <el-table-column label="等级" width="110">
            <template slot-scope="scope">
              <el-select v-model="scope.row.alertLevel" size="mini" @change="saveThreshold(scope.row)">
                <el-option label="红 (RED)" value="RED"></el-option>
                <el-option label="黄 (YELLOW)" value="YELLOW"></el-option>
              </el-select>
            </template>
          </el-table-column>
          <el-table-column label="启用" width="80">
            <template slot-scope="scope">
              <el-switch v-model="scope.row.isEnabled" :active-value="1" :inactive-value="0"
                @change="toggleRule(scope.row)"></el-switch>
            </template>
          </el-table-column>
        </el-table>
        </div>
      </el-main>
    </el-container>
  </el-container>
</template>
<script>
import api from '@/api'
const TYPE_CN = {
  DIFF: '差值对比', RATIO: '比例对比', MOM: '环比新增', NULL_CHECK: '必填/一致性',
  OUT_RANGE: '范围检查', MOM_EQ_ZERO: '环比为0', MOM_PCT: '环比百分比',
  MOM_EQ: '等于上月', EXISTENCE: '存在性', CROSS_DIFF: '跨表对比',
  EXISTENCE_AUTH: '运政缺失', EXISTENCE_SYS: '系统缺失', CROSS_DIFF_PCT: '跨表百分比',
  TREND_CONSISTENCY: '趋势一致', RATIO_CHANGE: '占比变化', AVG_DIST_CHANGE: '平均运距变化',
  PAX_PER_TRIP_CHANGE: '单车次载客人数变化', LOADED_RATIO_DIFF: '载货里程占比对比',
  FUEL_RANGE: '单耗超范围', FUEL_MOM: '单耗环比', FREIGHT_VS_H2032: '与货运月报对比',
  AVG_DIST_VS_H2032: '平均运距对比', LOADED_TON_RATIO: '载货吨位比值'
}
export default {
  name: 'RuleManage',
  data() {
    return { reportType: 'H2032', rules: [], loading: false }
  },
  methods: {
    typeLabel(t) { return TYPE_CN[t] || t },
    loadRules() {
      this.loading = true
      api.get('/rules/list', { params: { reportType: this.reportType } })
        .then(res => { this.rules = res.data || [] })
        .catch(() => { this.$message.error('规则加载失败') })
        .finally(() => { this.loading = false })
    },
    toggleRule(row) {
      api.post('/rules/toggle', null, { params: { id: row.id, enabled: row.isEnabled } })
        .then(() => { this.$message.success((row.isEnabled ? '已启用：' : '已停用：') + row.ruleCode) })
        .catch(() => { row.isEnabled = row.isEnabled ? 0 : 1; this.$message.error('操作失败') })
    },
    saveThreshold(row) {
      api.post('/rules/update', {
        id: row.id, threshold: row.threshold, alertLevel: row.alertLevel
      }).then(() => { this.$message.success('已保存：' + row.ruleCode) })
        .catch(() => { this.$message.error('保存失败') })
    }
  },
  mounted() { this.loadRules() }
}
</script>
<style scoped>
.el-header { background: #409EFF; color: white; line-height: 60px; font-size: 18px; }
</style>

 traffic-audit-web/src/views/UserManage.vue

@@ -1,2 +1,185 @@
<template><div>用户管理</div></template>
<script>export default { name: 'UserManage' }</script>
<template>
  <el-container>
    <el-header>交通统计报表审核系统 - ç”¨æˆ·ç®¡ç†</el-header>
    <el-container>
      <el-aside width="200px">
        <el-menu router :default-active="activeMenu">
          <el-menu-item index="/dashboard">工作台</el-menu-item>
          <el-menu-item index="/import">数据导入</el-menu-item>
          <el-menu-item index="/data">数据查看</el-menu-item>
          <el-menu-item index="/explain">企业解释</el-menu-item>
          <el-menu-item index="/audit">审核结果</el-menu-item>
          <el-menu-item index="/report">报表生成</el-menu-item>
          <el-menu-item index="/rules">规则管理</el-menu-item>
          <el-menu-item index="/users">用户管理</el-menu-item>
          <el-menu-item index="/login" @click="logout">退出登录</el-menu-item>
        </el-menu>
      </el-aside>
      <el-main>
        <div class="page-scroll">
          <h3>用户管理（负责模块决定报表生成页默认显示哪些模块）</h3>
          <div class="toolbar">
            <el-input v-model="keyword" placeholder="用户名 / å§“名" clearable style="width:220px" @keyup.enter.native="loadList" @clear="loadList"></el-input>
            <el-button type="primary" icon="el-icon-search" @click="loadList">查询</el-button>
            <el-button type="success" icon="el-icon-plus" @click="openEdit()">新增用户</el-button>
          </div>
          <div class="table-area">
            <el-table :data="list" border stripe size="small" v-loading="loading">
              <el-table-column prop="id" label="ID" width="60" align="center"></el-table-column>
              <el-table-column prop="username" label="用户名" width="120"></el-table-column>
              <el-table-column prop="realName" label="姓名" width="100"></el-table-column>
              <el-table-column prop="phone" label="手机号" width="130"></el-table-column>
              <el-table-column label="负责模块" min-width="240">
                <template slot-scope="{ row }">
                  <el-tag v-for="mk in moduleKeys(row.modules)" :key="mk" size="mini" style="margin-right:4px">{{ moduleLabel(mk) }}</el-tag>
                  <span v-if="!row.modules" style="color:#999">未配置（默认全部可见）</span>
                </template>
              </el-table-column>
              <el-table-column label="状态" width="80" align="center">
                <template slot-scope="{ row }">
                  <el-tag :type="row.status === 1 ? 'success' : 'info'" size="mini">{{ row.status === 1 ? '启用' : '停用' }}</el-tag>
                </template>
              </el-table-column>
              <el-table-column prop="createdAt" label="创建时间" width="170"></el-table-column>
              <el-table-column label="操作" width="140" align="center">
                <template slot-scope="{ row }">
                  <el-button type="text" size="mini" @click="openEdit(row)">编辑</el-button>
                  <el-button type="text" size="mini" style="color:#f56c6c" @click="removeUser(row)">删除</el-button>
                </template>
              </el-table-column>
            </el-table>
          </div>
        </div>
      </el-main>
    </el-container>

    <el-dialog :title="form.id ? '编辑用户' : '新增用户'" :visible.sync="dialogVisible" width="520px" @closed="resetForm">
      <el-form ref="userForm" :model="form" :rules="formRules" label-width="90px">
        <el-form-item label="用户名" prop="username">
          <el-input v-model="form.username" :disabled="!!form.id" placeholder="登录账号"></el-input>
        </el-form-item>
        <el-form-item label="密码" :prop="form.id ? '' : 'password'">
          <el-input v-model="form.password" type="password" :placeholder="form.id ? '留空则不修改密码' : '请输入初始密码'"></el-input>
        </el-form-item>
        <el-form-item label="姓名" prop="realName">
          <el-input v-model="form.realName" placeholder="真实姓名"></el-input>
        </el-form-item>
        <el-form-item label="手机号">
          <el-input v-model="form.phone" placeholder="选填"></el-input>
        </el-form-item>
        <el-form-item label="负责模块">
          <el-checkbox-group v-model="form.modules">
            <el-checkbox v-for="mo in moduleOptions" :key="mo.key" :label="mo.key">{{ mo.label }}</el-checkbox>
          </el-checkbox-group>
          <div class="form-tip">报表生成页默认只显示勾选的模块；不勾则全部可见</div>
        </el-form-item>
        <el-form-item label="状态">
          <el-radio-group v-model="form.status">
            <el-radio :label="1">启用</el-radio>
            <el-radio :label="0">停用</el-radio>
          </el-radio-group>
        </el-form-item>
      </el-form>
      <div slot="footer">
        <el-button @click="dialogVisible = false">取消</el-button>
        <el-button type="primary" :loading="saving" @click="saveUser">保存</el-button>
      </div>
    </el-dialog>
  </el-container>
</template>
<script>
import api from '@/api'
const MODULE_OPTIONS = [
  { key: 'freight', label: '货运报表' },
  { key: 'passenger', label: '公路旅客报表' },
  { key: 'invest', label: '投资报表' },
  { key: 'energy', label: '能耗报表' },
  { key: 'cityPassenger', label: '城市客运报表' }
]
export default {
  name: 'UserManage',
  data() {
    return {
      activeMenu: '/users',
      keyword: '',
      list: [],
      loading: false,
      dialogVisible: false,
      saving: false,
      moduleOptions: MODULE_OPTIONS,
      form: { id: null, username: '', password: '', realName: '', phone: '', modules: [], status: 1 },
      formRules: {
        username: [{ required: true, message: '请输入用户名', trigger: 'blur' }],
        password: [{ required: true, message: '请输入初始密码', trigger: 'blur' }]
      }
    }
  },
  mounted() { this.loadList() },
  methods: {
    logout() {
      localStorage.removeItem('token'); localStorage.removeItem('username'); localStorage.removeItem('realName'); localStorage.removeItem('modules')
      this.$router.push('/login')
    },
    loadList() {
      this.loading = true
      api.get('/user/list', { params: { keyword: this.keyword } })
        .then(res => { this.list = res.data || [] })
        .catch(() => this.$message.error('用户列表加载失败'))
        .finally(() => { this.loading = false })
    },
    moduleKeys(modules) {
      if (!modules) return []
      return modules.split(',').filter(Boolean)
    },
    moduleLabel(key) {
      const mo = MODULE_OPTIONS.find(x => x.key === key)
      return mo ? mo.label : key
    },
    openEdit(row) {
      this.dialogVisible = true
      this.$nextTick(() => {
        if (row && row.id) {
          this.form = {
            id: row.id, username: row.username, password: '', realName: row.realName || '',
            phone: row.phone || '', modules: this.moduleKeys(row.modules), status: row.status === 0 ? 0 : 1
          }
        } else {
          this.form = { id: null, username: '', password: '', realName: '', phone: '', modules: [], status: 1 }
        }
        this.$refs.userForm && this.$refs.userForm.clearValidate()
      })
    },
    resetForm() {
      this.form = { id: null, username: '', password: '', realName: '', phone: '', modules: [], status: 1 }
      this.$refs.userForm && this.$refs.userForm.clearValidate()
    },
    saveUser() {
      this.$refs.userForm.validate(valid => {
        if (!valid) return
        this.saving = true
        api.post('/user/save', this.form)
          .then(() => {
            this.$message.success('保存成功')
            this.dialogVisible = false
            this.loadList()
          })
          .catch(err => {
            const d = err && err.response && err.response.data
            this.$message.error((d && d.message) || '保存失败')
          })
          .finally(() => { this.saving = false })
      })
    },
    removeUser(row) {
      this.$confirm('确定删除用户「' + (row.realName || row.username) + '」吗？', '删除确认', { type: 'warning' })
        .then(() => api.post('/user/delete', null, { params: { id: row.id } }))
        .then(() => { this.$message.success('已删除'); this.loadList() })
        .catch(() => {})
    }
  }
}
</script>
<style scoped>
.toolbar { margin-bottom: 12px; display: flex; gap: 8px; align-items: center; }
.form-tip { font-size: 12px; color: #909399; line-height: 1.6; margin-top: 4px; }
</style>

 verify_final.py

File was deleted

 write_readme.py

File was deleted

 ÏîĿ˵Ã÷.txt

New file
@@ -0,0 +1,41 @@
交通货运统计审核系统 â€”— é¡¹ç›®äº¤ä»˜åŒ…
===================================

【项目结构】
  traffic-audit-server   åŽç«¯ï¼ˆSpring Boot，端口 8090）
  traffic-audit-web      å‰ç«¯ï¼ˆVue2 + Element UI，端口 8080，/api ä»£ç†åˆ° 8090）
  docs/ requirement/     éœ€æ±‚与设计文档
  test/                  æ ·ä¾‹æ•°æ®

【环境要求】
  JDK 8+、Maven 3.x、Node.js 14~18、MySQL 5.7/8.0

【数据库初始化】（首次运行前必须执行）
  1. å»ºåº“建表 + åŸºç¡€æ•°æ®ï¼šæ‰§è¡Œ docs/init.sql
     ï¼ˆè‡ªåŠ¨åˆ›å»º traffic_audit æ•°æ®åº“、全部业务表、用户权限与基础数据；
     ç™»å½•éªŒè¯ç ä¸ºå†…存版，无需 Redis）
  2. åŸŽå¸‚客运扩展表：执行 docs/sql_city_bus.sql、docs/sql_city_taxi.sql
     ï¼ˆå«å»ºè¡¨ä¸Žå®¡æ ¸è§„则；init.sql å·²å«å…¶ä½™å…¨éƒ¨è¡¨ï¼‰
  3. ä¿®æ”¹ traffic-audit-server/src/main/resources/application.yml
     ä¸­çš„数据库账号密码为本机实际值

【启动步骤】
  æ–¹å¼ä¸€ï¼ˆæŽ¨èï¼ŒWindows PowerShell，项目根目录执行）：
    powershell -ExecutionPolicy Bypass -File start-dev.ps1
    è„šæœ¬è‡ªåŠ¨å¯åŠ¨åŽç«¯(8090)与前端(8080)，并等待就绪。

  æ–¹å¼äºŒï¼ˆæ‰‹åŠ¨ï¼‰ï¼š
    åŽç«¯ï¼šcd traffic-audit-server && mvn spring-boot:run
    å‰ç«¯ï¼šcd traffic-audit-web && npm install && npm run serve

  è®¿é—®ï¼šhttp://localhost:8080
  é»˜è®¤è´¦å·ï¼šadmin / admin123

【重要配置】
  æ•°æ®åº“连接配置在：
    traffic-audit-server/src/main/resources/application.yml
  ï¼ˆå†…含开发环境账号密码，请按实际环境修改；
    é…ç½®æ¨¡æ¿è§åŒç›®å½• application.yml.example）

【备注】
  å‰ç«¯é¦–次启动前需 npm install（依赖未随包提供）。