.gitignore

@@ -103,3 +103,14 @@
_tmp_codexhome/
# Codex åº”用在本仓库根目录产生的产物目录（保留在本地，不入库）
outputs/
traffic-audit-server/config/application.yml

# ==== è¿‡ç¨‹æ—¥å¿—（本地自查用，不入库；2026-09-27 èµ·æŒ‰åŒäº‹æäº¤æ–¹å¼è°ƒæ•´ï¼‰====
docs/功能测试报告/
docs/工作日结/
# ==== æœ¬åœ°å¤‡ä»½ï¼ˆä¸å…¥åº“，2026-09-27）====
_backups/

# æ±‡æ€»å¤§è¡¨å·®å¼‚比对清单（过程产物，只留本地）
docs/问题汇总/_*.md
docs/问题汇总/_*.csv

 AGENTS.md

@@ -34,17 +34,22 @@
- æ²™ç®±å†… `Get-NetTCPConnection` ä¼šå› æƒé™â€œæ‹’绝访问”而静默失败，**不要**据此判定端口未监听；判断服务状态以 backend.log / frontend.log ä¸ºå‡†ã€‚
- ç”¨æˆ·è¦æ±‚：临时脚本/文件未经同意不删；导入失败要在页面显示行号；AI åˆ†æžç»“果要给结构化排版 + é€å­—输出动画。

## å·¥ä½œè§„范（2026-09-02 èµ·ï¼Œå¿…须遵守）
1. **每做完一个功能，立即测试并写《功能测试报告》**
## å·¥ä½œè§„范（2026-09-02 èµ·ï¼›2026-09-27 æŒ‰åŒäº‹æäº¤æ–¹å¼è°ƒæ•´ï¼‰

1. **每做完一个功能，立即测试**（测试要求不变）
   - æµ‹è¯•è‡³å°‘覆盖：正向用例（正常数据）、负向用例（错类型/错列位/缺列等）、入库抽查（与源文件逐项对齐）。
   - æŠ¥å‘Šå†™å…¥ `docs/功能测试报告/`，命名：`功能测试报告_<功能名>_<YYYY-MM-DD>.md`。
   - ã€ŠåŠŸèƒ½æµ‹è¯•æŠ¥å‘Šã€‹å†™åœ¨æœ¬åœ° `docs/功能测试报告/`，命名：`功能测试报告_<功能名>_<YYYY-MM-DD>.md`；**该目录已 gitignore，不入库**（自己留档/复查用）。
   - æŠ¥å‘Šé¡»åŒ…含：功能说明、测试环境、用例表（输入/预期/实际/结论）、发现的问题与处置、结论。
2. **每天下班前写《工作日结》，命名附日期**
   - å†™å…¥ `docs/工作日结/`，命名：`工作日结_<YYYY-MM-DD>.md`。
   - å†…容至少包含：今天做了什么（功能/修复）、测试结果摘要、遗留问题与待办、明天计划。
   - å½“天没有代码/测试工作时，也要写（一句话说明“今日无代码改动”即可）。
3. **git å·¥ä½œæµï¼ˆ2026-09-03 ç”¨æˆ·æŽˆæƒï¼Œæ— éœ€å†è¯¢é—®æ˜¯å¦æŽ¨é€ï¼‰**
   - æ¯æ¬¡ä¿®æ”¹ä»£ç /文档后：先测试并写《功能测试报告》/更新《工作日结》，再 `git fetch origin` ä¸Žè¿œç«¯ `main` å¯¹æ¯”合并（必要时解决冲突），确认无误后 commit å¹¶ push åˆ°å…¬å¸ gitea（`http://61.183.254.94:3000/r/trafficAudit.git`，账号 zyj）。
   - **入库的是结论**：把关键结论/口径/风险/待办写进 `HANDOFF.md`（必要时另写 `docs/交接文档_<日期>.md`、`docs/问题汇总/`），与该次代码改动**放在同一条提交**里。
2. **《工作日结》本地写、不入库**
   - å†™å…¥æœ¬åœ° `docs/工作日结/`，命名：`工作日结_<YYYY-MM-DD>.md`；**该目录已 gitignore，不入库**（给自己看）。
   - å†…容至少包含：今天做了什么、测试结果摘要、遗留问题与待办、明天计划；当天无代码/测试工作也要写一句话说明。
   - éœ€è¦äº¤æŽ¥çš„部分：把"当前状态 + å¾…办"追加到 `HANDOFF.md`（同事的做法就是这样）。
3. **git å·¥ä½œæµï¼ˆ2026-09-03 ç”¨æˆ·æŽˆæƒï¼Œæ— éœ€å†è¯¢é—®æ˜¯å¦æŽ¨é€ï¼›æäº¤ç²’度参考同事 xyc）**
   - **一条提交 = ä¸€ä¸ªæ”¹åŠ¨**：代码/脚本 + è¯¥æ”¹åŠ¨çš„说明文档（`HANDOFF.md` / æ–¹æ¡ˆ / å£å¾„清单）放在同一条提交里；不要为每个小改动单独建报告再单独提交。
   - message å†™æ³•ï¼š`feat(模块): â€¦` / `fix(模块): â€¦` / `docs: â€¦` / `docs(交接): â€¦`，一句话说清"改了什么"。
   - **禁止入库**：临时脚本与调试产物（`_tmp_*`、`_shots/`、`outputs/`）、构建产物（jar / dist / target）、密钥与口令、大体积备份（`*.sql` å…¨åº“导出）；过程日志与日结只留本地。
   - æŽ¨é€å‰ï¼šå…ˆæŒ‰ä¸Šé¢å®Œæˆæµ‹è¯•ï¼Œå† `git fetch origin` ä¸Žè¿œç«¯ `main` å¯¹æ¯”合并（必要时解决冲突），确认无误后 commit å¹¶ push åˆ°å…¬å¸ gitea（`http://61.183.254.94:3000/r/trafficAudit.git`，账号 zyj）。
   - è‹¥è¿œç«¯å·²æœ‰åŒäº‹æ–°æäº¤ï¼šå¿…须先合并/基于最新再推，禁止强推覆盖同事代码。
   - å…¬å¸ git è´¦å·å¯†ç åªé€šè¿‡æœ¬æœº git å‡­æ®/临时 askpass ä½¿ç”¨ï¼Œç¦æ­¢å†™è¿›ä»“库内任何文档或提交内容。


 HANDOFF.md

@@ -4,6 +4,112 @@
> **每天结束时**：把当天进展、踩过的坑、新需求、未完成事项更新到本文件，然后可以放心开新对话。
> **协作约定（2026-08-31）**：说「提交」= æœ¬åœ° commit + æŽ¨é€åˆ°è¿œç«¯ git（origin main，Gitblit），不再只做本地 commit。

## æœ€æ–°ï¼ˆ2026-10-02）

- **新模块（用户已验收，本次提交/推送）**：新增“专项统计-重要节假日”模块，含节假日配置、营业性客流、非营业性车流、客运系数 4 å¼ è¡¨ï¼›ç³»ç»Ÿé…ç½®èœå•ä»… admin å¯ç»´æŠ¤ï¼Œä¸“项统计-节假日支持导入、导出、模板下载和 Word å¿«æŠ¥ä¸‹è½½ã€‚
- **数据初始化**：从 `docs/专项统计/重要节假日/2026年十一数据.xlsx` åˆå§‹åŒ– 2024/2025 å¹´åä¸€å®¢æµã€è½¦æµå’Œ 2024-2026 å¹´å®¢è¿ç³»æ•°ï¼›æºè¡¨ 90 ä¸ªæ•°æ®å•å…ƒæ ¼å…¥åº“逐项比对差异 0。
- **日常导入口径**：只读取所选年份的当年列（2026 å¹´ä¸ºå„客流工作表 C åˆ—、普通国省道 D åˆ—）；历史年份不要求日常重导。
- **历史数据保护**：导入时先检查更早历史日期是否被修改。有变化则先不写库，返回差异清单，前端弹窗让用户选择“允许导入/不允许”；确认后才覆盖。接口参数 `allowHistoricalOverwrite=true`。
- **快报**：默认下载系统日期前一天的《湖北省国庆假期综合运输客流快报（10月X日）.docx》，用户可自选日期；环比/同比按增长、下降、持平输出。
- **Excel æµ®ç‚¹ç²¾åº¦ï¼ˆ2026-10-02 è¿½åŠ ï¼‰**：参考 `docs/Excel浮点数存储.txt`，新增 `HolidayNumberUtils`（`NumberToTextConverter.toText` + `BigDecimal`，`MathContext(15, HALF_UP)`）；节假日模块由 `Double` å…¨é¢æ”¹ `BigDecimal`；三张表数值列改 `DECIMAL(30,15)`；库内 6 æ¡å®¢è¿ç³»æ•°ç”± 2.3999999999999995 æ ¡æ­£ä¸º 2.4。迁移脚本 `docs/sql_holiday_decimal_migration.sql`。
- **菜单顺序**：“专项统计”已移到“报表生成”之后，当前为 æŠ¥è¡¨ç”Ÿæˆ -> ä¸“项统计 -> è§„则管理 -> ç”¨æˆ·ç®¡ç† -> ç³»ç»Ÿé…ç½®ã€‚
- **节假日删除复活修复（2026-10-02 è¿½åŠ ï¼‰**：原初始化逻辑每次启动补齐缺失的第 N æ—¥ï¼Œå¯¼è‡´ admin åˆ é™¤ 2026-10-08 åŽè¢«é‡æ–°æ’入；现改为仅 `holiday_calendar` æ•´è¡¨ä¸ºç©ºæ—¶é¦–次初始化。重启后 2026 å¹´åä¸€ä¿æŒ 10-01 è‡³ 10-07 å…± 7 å¤©ã€‚
- **普通国省道环比基期（2026-10-02 è¿½åŠ ï¼‰**：普通国省道 C åˆ—为可选环比基期，仅 2026 å¹´å¯ç”¨ï¼›å¡«å†™åŽåªå½±å“æ™®é€šå›½çœé“车流量自身环比 `当日 / åŸºæœŸ - 1`，未填写按前一日。`holiday_vehicle_flow.comparison_base` å·²å…¥åº“，导入导出与历史变更确认均已接入；折算人员流动量、总人员流动量和 Word å¿«æŠ¥ç»§ç»­æŒ‰ Excel åŽŸå…¬å¼ï¼Œä¸å—基期影响。2024/2025 ä¸ä½¿ç”¨ã€‚
- **快报首日口径（2026-10-02 è¿½åŠ ï¼‰**：假期第1天没有前一日环比基数，正文不输出“环比增长/下降/持平”短语，表格当日环比列为“—”；第2天起仍按实际前一日输出环比。已用 2025-10-01/02 å¿«æŠ¥å›žå½’验证。
- **快报百分比精度（2026-10-02 è¿½åŠ ï¼‰**：Word å¿«æŠ¥ä¸­åŒæ¯”/环比百分比统一保留1位小数（如6.79%显示6.8%、11.46%显示11.5%）；人次、车流等业务数值仍保留2位小数。
- **验证结果**：后端编译、前端构建、权限/CRUD/负向导入、历史变更两阶段导入、Excel å¯¼å‡ºã€Word å¿«æŠ¥ã€å‰ç«¯ admin/非 admin çƒŸæµ‹å‡é€šè¿‡ï¼›èœå•é¡ºåºã€å®¢è¿ç³»æ•° 2.4 å±•ç¤ºï¼ˆç³»ç»Ÿé…ç½®é¡µ + èŠ‚假日统计页）、`decimal(30,15)` åˆ—型、历史变更两阶段导入回归均已实测；功能测试报告与工作日结按 2026-09-27 æäº¤è§„范仅本地留存（不入库）：`docs/功能测试报告/功能测试报告_重要节假日专项统计_2026-10-02.md`、`docs/工作日结/工作日结_2026-10-02.md`。
- **运行状态**：后端 8090、前端 8080 å·²å¯åŠ¨ï¼›æ•°æ®åº“ `127.0.0.1:3305/traffic_audit`。测试产生的 2026 ä¸´æ—¶æ•°æ®å’Œå¯¼å…¥æ‰¹æ¬¡å·²æ¸…理。
- **关机收尾（2026-10-02）**：已停掉本次开发用后端 8090、前端 8080 åŠå„自进程树，端口均已释放；MySQL æœåŠ¡ä¿ç•™ã€‚当前可安全关机。
- **Git**：用户已于 2026-10-02 æ˜Žç¡®éªŒæ”¶é€šè¿‡ï¼›æœ¬æ¬¡æŒ‰è¦æ±‚合并远端 `origin/main` åŽæäº¤å¹¶æŽ¨é€ï¼Œä¸è¦†ç›–远端同事提交。
- **部署模板同步**：节假日 4 å¼ è¡¨å·²åŒæ­¥åˆ° `deploy-templates/db/init.sql`；`sql_holiday.sql` åŠä¸¤ä¸ªæ—§åº“迁移脚本随部署包发布，避免新包缺表。

## æœ€æ–°ï¼ˆ2026-09-28）

- **用户用 WPS ç¼–辑母版**：改《班线包车》边框、《道路运输周转量》字号，并删除《中口径明细》`AW` åˆ—（手工定稿同删）。已验证生成端正常：中口径明细 2024 åŠæ›´æ—©å—整体左移（跨页/同页公式自动改引用，`#REF!` 2→0）、中口径排名块 J..R â†’ A..I å‡æ­£ç¡®å¸¦å…¥äº§ç‰©ã€‚
- **⚠️ WPS ä¿å­˜çš„连带损坏（待回补）**：《班线包车》2019/2020 å—约 **590 æ ¼**内容丢失（`FN/FO/FM`、`FP:FT`、`GE` å˜ç©ºï¼›`EO/EQ/ES/EU/EW/EY/DT/DW...EM` å…± **144 æ ¼**变 `#DIV/0!`）。生成件已带出（该页 `#DIV/0!` 228→372）。**待用户确认后按备份/定稿回补（只补值与公式，保留其边框与字号）。**
- **口径落地「缺数留空」**：母版《 è´§è¿ã€‹è¡Œ 90/93（仙桃 è§„上两行）、108/111（林区）在 2021、2022 å¹´å—çš„ 78 ä¸ª `0` å€¼å·²æ¸…空（与手工定稿按表头对齐逐格核对：母版=0 ä¸”定稿=空 78 æ ¼ã€å†²çª 0 æ ¼ï¼‰ï¼›ä»£ç  `FreightCalc.buildMetrics` å½“月分支改为「该月无规上记录 â†’ ç•™ç©ºã€ï¼Œä¸å†å†™ 0（累计分支不变）。
- **纠正一条错判**：此前「程序少一列 11 æœˆçŽ¯æ¯”」不成立——生成件与手工定稿的环比期间集合完全一致（12月…1月 å…± 12 åˆ—）；差异根因是手工定稿《 è´§è¿ã€‹åœ¨ 2025 å¹´å—多一列**无表头辅助列**（`U`，74 æ ¼ï¼‰ï¼Œè‡ªè¯¥åˆ—起手工整体右移 1 åˆ—。**比对必须按表头期间对齐，不能按列位置比。**
- **验证**：生成两次（约 15 ç§’/次），第二次相对第一次**仅 78 æ ¼ 0→空**，错误值数量不变；`公交!S5=98460.97` ç­‰ç¼“存值抽查保留。
- **运行状态**：后端已按 `start-dev.ps1` é‡å¯ï¼ˆæ–° PID，8090/8080 åœ¨è·‘）；本机库仍为 `localhost:3308/traffic_audit`。
- **✅ ç­çº¿åŒ…车回补完成（09-28 ä¸‹åˆï¼‰**：用户确认后按 09-27 æ¯ç‰ˆå¤‡ä»½ï¼ˆ`_bak_202608母版文本数字转数值前_20260927.xlsx`）XML ç²¾å‡†å›žè¡¥ã€Šç­çº¿åŒ…车》2019/2020 å— â€”— **该页与 09-27 æ¯ç‰ˆé€æ ¼ä¸€è‡´ï¼ˆ0 å·®å¼‚）**，错误值回到 `#REF!` 8 / `#DIV/0!` 228；母版其它页未受影响。验收生成：与 09-27 ç”Ÿæˆä»¶ (6) æ¯”对错误值逐页一致，差异仅剩既定改动（` è´§è¿` 78 æ ¼æ¸… 0、中口径明细 4915 æ ¼åˆ åˆ—位移、中口径排名 672 æ ¼å—位移、班线包车 82 æ ¼æµ®ç‚¹å°¾å·®/0-空）。
- **差异清单口径更新（09-28，用户确认）**：① ` è´§è¿` æ–°å¢žçš„「规上+规下货运量」「规下货运量」各 17 è¡Œï¼ˆæ¯ç‰ˆè®¾è®¡ï¼Œå…± 34 è¡Œï¼‰ä¸è®¡å·®å¼‚；② ` è´§è¿!U5:U112` æ— è¡¨å¤´è‰ç¨¿åˆ—不计；③ æŽ’名表「当月块」为母版设计不计；④ å¸‚州短名/全名不影响（工具归一化）；⑤ å°å·®å¼‚（取整尾差/文本型数字）只计数，只列差异大的并附原因。工具 `docs/工具/汇总大表差异比对.py` å·²æŒ‰æ­¤æ›´æ–°ï¼Œä¸¤ä»½æ¸…单已重生成。
- **新发现（待核对）**：`班线包车!EO36/FN36/FO36`（荆门 å®¢è¿é‡ 2020 ç´¯è®¡/累计同比）**程序生成时重算为 -2731.41 / -1.0008 / -1.0002**，而母版与手工定稿均为 0.181777 / 2312.2199 / -0.586419 â†’ ç–‘母版 2020 å¹´å—分母为 0，需核对公式与数据。
- **汇总大表差异比对（09-28，工具已固化口径）**：`docs/工具/汇总大表差异比对.py`（逐页按行/列标签序列对齐，可处理多列/多行/重复表头）。**清单属过程产物只留本地**（`docs/问题汇总/_清单_*.md/.csv`，已 gitignore ä¸å…¥åº“）。
  - å·²ç¡®è®¤å£å¾„（不再重复确认/上报）：① è´§è¿æ¯å¸‚å·ž 6 è¡Œ vs æ‰‹å·¥ 4 è¡Œï¼ˆæ–°å¢žã€Œè§„上+规下货运量」「规下货运量」各 17 è¡Œï¼‰å±žæ¯ç‰ˆè®¾è®¡ï¼Œè¡Œå·åç§»æŒ‰"地区+指标"对齐后一致；② ` è´§è¿` U åˆ—（U2:U118）为人工草稿；③ ä»…手工有且**无表头**的列 = è‰ç¨¿ï¼›â‘£ æµ®ç‚¹å°¾å·®ã€æ–‡æœ¬åž‹æ•°å­—忽略；⑤ æŽ’名表「当月块」为母版设计；⑥ å¸‚州短名/全名不影响。
  - **需处理（数值）**：`班线包车!EO36/FN36/FO36`（荆门 å®¢è¿é‡ 2020 ç´¯è®¡/累计同比）——程序生成时重算为 -2731.41 / -1.0008 / -1.0002，母版与手工定稿均为 0.181777 / 2312.2199 / -0.586419（疑母版 2020 å¹´å—分母为 0），待核对；` è´§è¿` 2022 å¹´å„市州「累计同比」10 æ¡ï¼ˆä¸šåŠ¡å·²ç¡®è®¤**软件对**，不改）。
  - å…¶ä½™å¾…办：手工侧 4 å¤„脏数据（`班线包车!IL4/IL5` æ–­é“¾ã€`IL50` åå¼•å·ã€` è´§è¿!EA93/EA111` çš„ `#DIV/0!`）、286 æ ¼æ–‡æœ¬åž‹æ•°å­—、304 æ ¼è‰ç¨¿åˆ—；母版 11 ä¸ª `#REF!` + 356 ä¸ª `#DIV/0!`；`城市客运` ç¬¬ 2 è¡Œç¬¬ 3 ä¸ªæœˆèµ·è¡¨å¤´ä¸ºæ—¥æœŸåºåˆ—号；缺 2026-09 æ¯ç‰ˆï¼›å¯¼å‡ºå‰åŸºæ•°ä½“检（P0-3）。
- **09-28 æ”¶å°¾ï¼š`班线包车` 3 æ ¼é‡ç®—问题已修**：`EO36`/`FN36`/`FO36` åœ¨æ¯ç‰ˆé‡Œæ”¹ä¸º**静态值**（0.181777001400256 / 2312.2199 / -0.586418964965219，与手工定稿一致），并把受影响的共享公式组孤儿子格（35 æ ¼ï¼‰ä¸€å¹¶é™æ€åŒ–（值零变化）。重新生成验证：生成件/母版/定稿三边一致，与上一版生成件仅 34 æ ¼ä¸ºç²¾åº¦è¡¨ç¤ºå·®å¼‚、无数值变化。
- **当前"需处理"仅剩 16 æ¡**（均属手工侧/业务已确认，非程序问题）：` è´§è¿` EA92~EA112 å…± 12 æ¡ï¼ˆ2022 å„市州累计同比，2021 å¹´åŸºæ•°å£å¾„不同，业务已确认软件对；含手工 `#DIV/0!` 2 æ¡ï¼‰ã€`班线包车` IL4/IL5（手工 `#REF!`）/IL50（手工反引号）3 æ¡ã€`城市汇总!G20` è¡¨å¤´æŽªè¾ž 1 æ¡ã€‚其余全部按口径忽略（草稿列/行号偏移/当月块/浮点尾差/文本型数字）。
- **未清项（有意保留）**：母版 11 ä¸ª `#REF!` + 356 ä¸ª `#DIV/0!` åŽ†å²é”™è¯¯å€¼æœªæ¸…——手工定稿同类约 15 + 358，单清一边会凭空多出单边差异；要清需两边一起。
- **确认差异清单（本地）**：`docs/问题汇总/_已确认差异清单_2026-08_20260928.md`（不入库）。
- **09-28 å£å¾„全部落地，差异清单"需处理"归零**：
  - â‘  æŒ‰è½¯ä»¶ï¼šæ‰‹å·¥å®šç¨¿ã€Š è´§è¿ã€‹EB64~EB78 ç­‰ 12 æ ¼ 2022 ç´¯è®¡åŒæ¯” + ã€Šç­çº¿åŒ…车》IL4/IL5/IL50 å·²æŒ‰è½¯ä»¶å€¼åŒæ­¥ï¼ˆå¤‡ä»½ `2026å¹´8月客运量、货运量定稿_同步软件前_20260928.xlsx`）。
  - â‘¡ æŒ‰æ‰‹å·¥ç»Ÿä¸€æŽªè¾žï¼šæ¯ç‰ˆã€ŠåŸŽå¸‚汇总!G20》改为手工写法"2025å¹´1-12月全省累计完成城市客运量情况"（备份 `_bak_202608母版_0928措辞前.xlsx`）。
  - â‘¢ åŽ†å²é”™è¯¯å€¼ç•™ç™½ï¼šæ¯ç‰ˆ 363 æ ¼ï¼ˆ`_bak_202608母版_0928留白前.xlsx`）、手工定稿 379 + å°¾åˆ— 6 æ ¼ï¼ˆ`..._留白尾列前_20260928.xlsx`）→ ä¸¤è¾¹çŽ°å‡ä¸º 0 ä¸ª `#REF!`/`#DIV/0!`。
  - ç»“果：按当前母版重新生成 2026-08 åŽï¼Œä¸Žæ‰‹å·¥å®šç¨¿çš„**需处理差异 = 0**，其余全部落在"已忽略（约定差异）"。清单：`docs/问题汇总/_清单_母版最新生成件_20260928.md/.csv`（本地，不入库）。
  - æ³¨æ„ï¼šæ¡Œé¢é‚£ä»½ `生成_道路运输量汇总表_2026-08.xlsx` æ˜¯æ—§å¯¼å‡ºï¼ˆå«æ—§é”™è¯¯å€¼/旧基数），与更新后的定稿比对会显示较多差异，以"母版重新生成件"为准。
- **无表头草稿列清单（9 å¤„，共 539 æ ¼ï¼‰**：`公交/出租/网约车!U`（各 72）、`城市客运!U`（36）、`班线包车!DU`（55，表头"1-3月累计"）、`中口径明细!U`（90）、`中口径客运量!AB`（180）、` è´§è¿!V` ä¸Ž ` è´§è¿!AX`（各 74，用户所指 U åˆ—在手工那份右移一列）。母版/生成件**已全部清空**，手工定稿仍保留 â†’ å¯¹æ¯”时归入「已知设计(无表头草稿列)」。其余"无表头列"是合并表头的正常列（` è´§è¿!C…Q` æœˆä»½å€¼åˆ—、各年块尾部累计/累计同比列、排名页 R åˆ—等），两边都有、非草稿。明细见 `docs/问题汇总/_已确认差异清单_2026-08_20260928.md`。
- **待办**：① æŽ’名页结构（块顺序、标题措辞、市州名短名/全名、周转量排名多 7 è¡Œï¼‰ï¼›â‘¡ æŽ’名页结构（块顺序、标题措辞、市州名短名/全名、周转量排名多 7 è¡Œï¼‰ï¼›â‘¢ ç¼º 2026-09 æ¯ç‰ˆã€å¯¼å‡ºå‰åŸºæ•°ä½“检（P0-3）。

## æœ€æ–°ï¼ˆ2026-09-27）

- **提交规范改为同事方式（用户 09-27 å†³å®šï¼Œå·²å†™å…¥ AGENTS.md）**：
  1. ã€ŠåŠŸèƒ½æµ‹è¯•æŠ¥å‘Šã€‹ã€Šå·¥ä½œæ—¥ç»“》改为**本地写、不入库**（`docs/功能测试报告/`、`docs/工作日结/` å·² gitignore，本次 109 ä¸ªæ–‡ä»¶ç§»å‡ºä»“库、本地文件全部保留；其中《模块功能验证状态矩阵_2026-09-02》属团队共享信息，已移到 `docs/` æ ¹ç›®å½•ç»§ç»­å…¥åº“）；
  2. **入库的是结论**：关键结论/口径/风险/待办写进本文件（`HANDOFF.md`）或 `docs/交接文档_*.md`、`docs/问题汇总/`，与该次代码改动放在同一条提交；
  3. æäº¤ç²’度与 message：一条提交一个改动（代码+相关文档），前缀 `feat(模块):` / `fix(模块):` / `docs:` / `docs(交接):`；禁止入库临时脚本/调试产物/构建产物/密钥/大体积 sql。
  > å‚考数据：同事 xyc 55 æ¬¡æäº¤ä¸­ 37 æ¬¡æ›´æ–°æœ¬æ–‡ä»¶ã€åŠŸèƒ½æµ‹è¯•æŠ¥å‘Šä»… 4 æ¬¡ã€æ—¥ç»“ 7 æ¬¡ï¼›æ­¤å‰æˆ‘æ–¹ 144 æ¬¡æäº¤é‡Œå« 102 ä»½æŠ¥å‘Š + 106 ä»½æ—¥ç»“。
- **打包去密（根因已修）**：旧部署包的 jar å†…ç½® `BOOT-INF/classes/application.yml` å¸¦ç€**真实密钥与库口令**（外层 application.yml å¹²å‡€ã€è¿è¡Œæ—¶ä»¥å¤–部为准，但 jar å¯è§£åŽ‹æ˜Žæ–‡å¯è§ï¼›ä¸” zip åŽ‹ç¼©å¯¼è‡´ç›´æŽ¥ grep æœä¸åˆ°ï¼‰ã€‚
  çŽ°å·²æ”¹ä¸ºï¼š**进 jar çš„配置只有占位符**（`${TRAFFIC_DB_*}`、`${DEEPSEEK_API_KEY:}`、`${TRAFFIC_JWT_SECRET:...}`）；本机真实值走 **Windows ç”¨æˆ·çŽ¯å¢ƒå˜é‡**（`TRAFFIC_DB_PASSWORD` / `DEEPSEEK_API_KEY`），`start-dev.ps1` å¢žåŠ äº†ä»Žæ³¨å†Œè¡¨è¡¥é½çš„兜底。
- **新增脚本（已入库）**：`pack-deploy.ps1`（一键打包：构建 â†’ **解压 jar åŽ»å¯†è‡ªæ£€ï¼Œå‘½ä¸­çœŸå®žå¯†é’¥/明文口令即中止** â†’ é‡å»ºå‰ç«¯ â†’ ç»„装部署包到 `E:\试验\traffic-audit-deploy-<yyyyMMdd>`）、`set-secrets.ps1`（轮换后交互式更新本机环境变量）、`deploy-templates/`（打包模板入库：外部 application.yml、启动脚本、nginx ç¤ºä¾‹ã€db å»ºè¡¨ sql、部署 README——原先只在未跟踪的旧包里，删包即丢）。
- **清理旧部署件（用户确认后执行）**：删除 `E:\试验\traffic-audit-deploy-20260913`（目录 + **69.9 MB çš„ zip**）、`deploy\traffic-audit-deploy-20260913`、`_deploytest`、空 `out`/`deploy`；旧 `target` jar ç”± `mvn clean` è¦†ç›–。全盘复查（仓库 + `E:\试验`）：**已无任何含明文 key çš„ jar / åŽ‹ç¼©åŒ… / æ–‡æœ¬æ–‡ä»¶**。
- **干净新包已产出**：`E:\试验\traffic-audit-deploy-20260927`（336 æ–‡ä»¶ / 96 MB，前端含最新「按市州汇总」；jar å†…置配置全占位符）。
- **运行状态（09-27 å®žæµ‹ï¼‰**：dev åŽç«¯ `8090`、前端 `8080` åœ¨è¿è¡Œï¼›**本机数据库为 MySQL80 `localhost:3308/traffic_audit`（root/口令走环境变量）**——注意 `docs/交接文档_2026-09-23.md` å†™çš„ `3305` æ˜¯**同事机器**的配置，本机没有 3305，别再照抄。
- **待办（接手优先）**：
  1. **【需用户】轮换已泄露的 DeepSeek key**（控制台新建 + åˆ æ—§ â†’ è·‘ `set-secrets.ps1`）；
  2. **【需用户】服务器换包**：删旧包/zip â†’ æ‹· `traffic-audit-deploy-20260927` â†’ æ”¹ `backend\application.yml` æ•°æ®åº“三处（需要 AI åˆ†æžå†å¡« `deepseek.api-key`）→ `start-backend.cmd`；
  3. P0 ä¸‰é¡¹ä¸å˜ï¼šP0-2 äº¿å…ƒæŠ•èµ„项目按 Q7 æŒ‰æœˆè¿½åˆ—、P0-3 å¯¼å‡ºå‰åŸºæ•°ä½“检 +《数据缺失清单》页、P0-4 ç¼º 2026-06/09 æ¯ç‰ˆï¼›
  3.1 **汇总大表现状复核（2026-09-27 å®žæµ‹ï¼Œæ¯ç‰ˆ `docs/生成汇总大表/2026å¹´8月道路运输量汇总表.xlsx` + æœ€è¿‘生成件）**：
      - **累计列公式没覆盖到当期（实测 306 æ ¼ï¼‰æœªè½å®ž**，确切位置（母版 `docs/生成汇总大表/2026å¹´8月道路运输量汇总表.xlsx`）：
        Â· `公交!U5:U76`、`出租!U5:U76`、`网约车!U5:U76` å„ 72 æ ¼ = 216 æ ¼ï¼Œå…¬å¼ `=V5+X5+Z5+AB5+AD5+AF5`（只累加 2025 å¹´ 1~6 æœˆï¼›U åˆ—表头为空，位置在"2025å¹´1月"块左侧，对应 2026 å—çš„ `S` åˆ—"2026年累计"，语义即"2025 å¹´ç´¯è®¡"）；
        Â· `城市客运!U4:U39` 36 æ ¼ï¼ˆåŒæ¨¡å¼ï¼Œåª 6 ä¸ªæœˆï¼‰ï¼›`班线包车!DU4:DU57` 54 æ ¼ï¼ˆ`DU2` è¡¨å¤´ç›´æŽ¥å†™"1-3月累计"，只 3 ä¸ªæœˆâ€”—属版式未随月份扩展）。
        â†’ ä¸šåŠ¡å£å¾„为"可清空留空"；**生成件与母版逐格相同**（证实程序只补当期列、不碰历史列）。09-22 å·®å¼‚报告按另一分页口径统计为"304 æ ¼ï¼ˆå«ä¸­å£å¾„明细 88 æ ¼ï¼‰"，本次按公式模式定位到的是上述 306 æ ¼ï¼Œä¸¤è€…为同一类问题、分页归类不同。
      - **2026-09-27 å·²å¤„置：母版里的"人工核算草稿累计列"整体清空**（用户确认"这一列都可以留空，是人工核算时弄的草稿"）。清空范围共 **577 æ ¼**：`公交/出租/网约车!U5:U76`、`城市客运!U4:U39`、`班线包车!DU4:DU57`（含表头 `DU2`"1-3月累计"）、`中口径明细!U99:U188`、`中口径客运量!AB5:AB188`。
        Â· ä¾æ®ï¼šè¿™äº›åˆ—在整本工作簿里**没有任何公式引用**（全簿扫描 0 å‘½ä¸­ï¼‰ï¼Œä¸”程序**不写它们**（生成件与母版逐格相同）→ **只改母版即可，无需改代码**。
        Â· åšæ³•ï¼šç›´æŽ¥æ”¹ xlsx å†…部 XML（只去对应单元格的 `<f>/<v>`、保留样式），**避免 openpyxl ä¿å­˜å¯¼è‡´å…¨ç°¿å…¬å¼ç¼“存值丢失**（该坑已实测复现：用 openpyxl å­˜ä¸€æ¬¡åŽ `公交!S5` ç”± 98460.97 å˜ None，会破坏"中口径排名用母版 2025 é™æ€åˆ—"）。
        Â· éªŒè¯ï¼šé‡æ–°ç”Ÿæˆ 2026-08（母版变更使缓存自动失效，`staleCache=true`）→ æ–°æ—§ç”Ÿæˆä»¶é€æ ¼æ¯”对：**仅这 577 æ ¼å˜ä¸ºç©ºï¼Œ19 é¡µç­¾ä¸Žå°ºå¯¸ä¸å˜ï¼Œå…¶å®ƒä¸€å¾‹ä¸åŠ¨**；依赖母版缓存值的口径（中口径排名 M3、道路运输周转量 G4、货运量排名 B4、城市汇总 B3、公交 S5/Q5、中口径明细 C99、班线包车 Q4）**全部一致**。
        Â· å¤‡ä»½ï¼ˆæœ¬åœ°ä¿ç•™ã€ä¸å…¥åº“）：`docs/生成汇总大表/_bak_202608母版清空草稿累计列前_20260927.xlsx`；新生成件已存 `D:\桌面\生成数据\生成_道路运输量汇总表_2026-08 (4).xlsx`。
        Â· **表头措辞修复（按人工定稿为准）**：`轨道、轮渡!R2`、`R11` ç”±æ¯ç‰ˆè‡ªå¸¦çš„"8月与去年同比"改为"同比"（与该页 `T2/T11`"累计同比"体例一致、与手工定稿一致；程序不写这两格，故只改母版）。
          éªŒè¯ï¼šé‡æ–°ç”Ÿæˆ 2026-08 â†’ æ–°æ—§ç”Ÿæˆä»¶é€æ ¼æ¯”对 **仅这 2 æ ¼æ–‡å­—变化，19 é¡µç­¾ä¸Žå°ºå¯¸ä¸å˜ã€å…¶å®ƒä¸€å¾‹ä¸åŠ¨**。
        Â· **判定为"程序正确、不改"的两处**：① `道路运输周转量!A23` ç¨‹åº"2026å¹´8月全省完成交通周转量情况"（该块是**当月值**：全省 2,301,720 vs ç´¯è®¡å— 17,749,657 ä¸‡å¨å…¬é‡Œï¼‰â†’ æ‰‹å·¥å®šç¨¿å¤šå†™äº†"累计"；② ` è´§è¿!EA92:EA112` 2022 å¹´ç´¯è®¡åŒæ¯” 10 æ¡ï¼ˆä¸šåŠ¡å·²ç¡®è®¤è½¯ä»¶å£å¾„正确）。
        Â· **文本型数字统一为数值（用户口径"按程序对的改"）**：母版 157 æ ¼æ–‡æœ¬åž‹æ•°å­— â†’ æ•°å€¼ï¼ˆ`公交` 153 = AF 68 + M 68 + G 17；`轨道、轮渡` 4 = M 2 + E 2），仍用 XML ç²¾å‡†æ”¹ç±»åž‹ï¼ˆç¼“存值全部保留）。重新生成 2026-08 â†’ ä¸Žä¸Šä¸€ç‰ˆæ¯”对：**仅 68 æ ¼ç±»åž‹å˜åŒ–（str→数值、数值相同），无任何值/尺寸变化**（其余 89 æ ¼ç¨‹åºæœ¬å°±ä¼šå†™æ•°å€¼ï¼‰ã€‚注：比对里另有 286 æ¡"文本型数字"差异在**手工定稿侧**（手工存文本），需手工侧统一或忽略。
        Â· **排名页"两个块顺序对调"（实为顺序问题，不是多了一张表）**：程序 ä»¥æ¨¡æ¿ `docs/货运/生成_货运量排名.xlsx`（模板本身=累计块在行1、当月块在行23）填充 â†’ `货运量排名` ç¨‹åº=行1累计/行22当月，手工=行1当月（"2026å¹´8月各市州货运量排名"）/行22累计；`货运周转量排名` ç¨‹åº 44×18（累计在前）vs æ‰‹å·¥ 51×18（当月在前、且多 7 è¡Œå¾…细看）。**用户口径：手工为准** â†’ éœ€æ”¹æ¨¡æ¿ï¼ˆä¸¤å—对调）+ ç›¸åº”代码（块定位/标题写法 `ReportExportService:961-966/1315/1575-1583`）+ å¸‚州名由 `RegionUtil.shortName()` æ”¹å…¨åï¼›ä¼° 0.5~1 å¤©å«å›žå½’，待开工。
        Â· **手工多出的"辅助列"清单**：` è´§è¿` å¤š 1 åˆ—（无表头，位于"同比"之后、2025 å¹´ 1 æœˆä¹‹å‰ â†’ å®žä¸º `U` åˆ—"2025 å¹´ 1-8 æœˆç´¯è®¡"辅助列，74 æ ¼ï¼Œä»Ž V åˆ—起手工整体右移）；`城市客运` å¤š `AJ`="2025å¹´1-7月累计"（母版 09-20 å·²åˆ ã€ç¨‹åºå·²ä¸è¾“出）；`班线包车` å¤š `DU`="1-3月累计"（即本次清空的草稿列）；`道路运输周转量` æœ«å°¾å¤š 2 åˆ—（Z/AA，**表头与内容均为空**）。
        Â· å–整尾差 194 æ¡ï¼šç”¨æˆ·æ˜Žç¡®"不用管"。

        Â· **仍待业务定的版式/措辞项**：`货运量排名`/`货运周转量排名` çš„标题、表头（程序"累计完成(万吨)" vs æ‰‹å·¥"规上货运量(万吨）"）与市州名（程序按设计用短名"武汉/恩施/林区"、手工用"武汉市"等全名）——需业务确认以哪版为准。

        Â· âš  **待同事确认**：手工定稿侧也把这些草稿列留空，否则比对会从"程序有值/手工有值"变成"程序空/手工有值"（同类差异、方向相反）。

        Â· **清空的 7 åˆ—对照表（供同事复核；引用数为清空前的全簿扫描）**：

        | é¡µç­¾ | åˆ— / èŒƒå›´ | æ¸…空格数 | åŽŸè¡¨å¤´ | å…¬å¼è¯­ä¹‰ | æ¸…空前缓存值（首行样例） | åŒé¡µå¼•ç”¨ | è·¨é¡µå¼•ç”¨ |
        | --- | --- | ---: | --- | --- | --- | ---: | ---: |
        | å…¬äº¤ | `U`（U5:U76） | 72 | ï¼ˆæ— è¡¨å¤´ï¼‰ | `=V5+X5+Z5+AB5+AD5+AF5` â†’ 2025 å¹´ 1~6 æœˆç´¯è®¡ | 88908.91 | 0 | 0 |
        | å‡ºç§Ÿ | `U`（U5:U76） | 72 | ï¼ˆæ— è¡¨å¤´ï¼‰ | `=V5+X5+Z5+AB5+AD5+AF5` â†’ 2025 å¹´ 1~6 æœˆç´¯è®¡ | 39797.94 | 0 | 0 |
        | ç½‘约车 | `U`（U5:U76） | 72 | ï¼ˆæ— è¡¨å¤´ï¼‰ | `=V5+X5+Z5+AB5+AD5+AF5` â†’ 2025 å¹´ 1~6 æœˆç´¯è®¡ | 16384.07 | 0 | 0 |
        | åŸŽå¸‚客运 | `U`（U4:U39） | 36 | ï¼ˆæ— è¡¨å¤´ï¼‰ | `=V4+X4+Z4+AB4+AD4+AF4` â†’ 2025 å¹´ 1~6 æœˆç´¯è®¡ | 206639.67 | 0 | 0 |
        | ç­çº¿åŒ…车 | `DU`（DU4:DU57） | 54 | 1-3月累计 | `=DO4+DQ4+DS4` â†’ 1~3 æœˆç´¯è®¡ | 5566.8922 | 0 | 0 |
        | ä¸­å£å¾„明细 | `U`（U99:U188） | 90 | ï¼ˆæ— è¡¨å¤´ï¼‰ | `=V99+X99+Z99+AB99+AD99+AF99+AH99` â†’ 2025 å¹´ 1~7 æœˆç´¯è®¡ | 1102278.385724 | 0 | 0 |
        | ä¸­å£å¾„客运量 | `AB`（AB5:AB188） | 184 | ï¼ˆæ— è¡¨å¤´ï¼‰ | `=AC5+AE5` â†’ 2024 å¹´ 1~2 æœˆç´¯è®¡ | 6088.1871 | 0 | 0 |

        Â· **⚠ åŒååˆ—别清错（反例对照）**：`中口径明细!AB3 = "2025å¹´4月"` æ˜¯**正常月份列**，被 **700+ å¤„同页 + 34 å¤„跨页公式引用**（例如 `中口径明细!J5 = I5/AB5-1` 2026 å¹´ 4 æœˆåŒæ¯”、`T5 = S5/SUM(V5,X5,Z5,AB5,…)-1` ç´¯è®¡åŒæ¯”、`AT5 = X5+V5+Z5+AB5+…` 2025 ç´¯è®¡ã€`中口径客运量!I11 = ä¸­å£å¾„明细!AB11`），**本次未动、也不能清**。判据：该列**有表头**、**被引用数远大于 0**、公式语义是"被别的格引用"而不是引用其它月份列。

      - **生成件里错误值 356 ä¸ª `#DIV/0!` + 13 ä¸ª `#REF!`**：班线包车 228+8、中口径明细 64+2、货运 38+3、中口径客运量 26；业务口径未定（是否清成空白）。
      - **城市客运页表头仍是日期序列号（确证未修）**：母版与生成件第 2 è¡Œç¬¬ 3 ä¸ªæœˆèµ·å‡ä¸ºåºåˆ—号（G2=46082、I2=46113…），1、2 æœˆæ˜¯æ–‡å­—ï¼›`fixCityMonthHeaderText()` æœªè¦†ç›–该页 â†’ "按表头文字匹配列"方案在该页失效。（此前文档标"待核实"，现已确证。）
      - ç¼º 2026-09 æ¯ç‰ˆï¼ˆç›®å½•ä»… 7 æœˆ/8 æœˆ/版式原型 + 2 ä¸ª `_bak_*`）→ 9 æœˆå‡ºè¡¨ä¼š `ready=false`，需拍板方案 A（程序扩列）/ B（Excel å°å·¥å…·ï¼‰ã€‚
  4. æ±‡æ€»å¤§è¡¨ 304 æ ¼ã€Œ2025 ç´¯è®¡åˆ—少加 7、8 æœˆã€æ¸…空（业务已确认口径，待执行）；
  5. æœ¬æœºåŽ†å²ä¸´æ—¶ç›®å½•å¾…清（`outputs/` 41MB、`_shots/`、`_test_check*`、`_test_passenger`、`.tmp_*`、`_tmp_codexhome`）；`_给同事_2026-09-21/`（52MB å…¨åº“备份）属交付件，未动。

## æœ€æ–°ï¼ˆ2026-09-23）

- **已同步**：本地 `main` å¿«è¿›åˆå¹¶å…¬å¸ `origin/main` æœ€æ–° `8b739ce`（同事 09-22 å…³æœºå¿«ç…§ç»Ÿä¸€ç‰ˆï¼‰ï¼Œåˆå¹¶åŽ `HEAD = 8b739ce = origin/main`，工作区干净。

 deploy-templates/README-²¿Êð˵Ã÷.txt

New file
@@ -0,0 +1,71 @@
TrafficAudit äº¤é€šè´§è¿ç»Ÿè®¡å®¡æ ¸ç³»ç»Ÿ â€”— éƒ¨ç½²åŒ…（{stamp}）
========================================================

【目录结构】
  backend/
    traffic-audit-server-1.0.0-SNAPSHOT.jar  åŽç«¯ç¨‹åºï¼ˆå«å…¨éƒ¨ä¾èµ–，**已内嵌前端**）
    docs/                                    æŠ¥è¡¨æ¨¡æ¿ä¸Žè¿è¡Œæ•°æ®ç›®å½•ï¼ˆå¿…需，勿删）
    application.yml                          å¤–部配置（改这里即可，无需重新打包）
    start-backend.cmd / start-backend.sh     å¯åŠ¨è„šæœ¬
  frontend/
    dist/                                    å‰ç«¯æž„建产物（备用：想用 nginx æ‰˜ç®¡æ—¶ç”¨ï¼‰
    nginx.conf.example                       nginx é…ç½®ç¤ºä¾‹
  db/
    init.sql                                 å»ºåº“建表 + é¢„置账号（必须执行）
    sql_city_bus.sql                         åŸŽå¸‚客运-公交月度表（必须执行）
    sql_city_taxi.sql                        åŸŽå¸‚客运-出租月度表/出租授权表（必须执行）
    sql_wyc.sql                              ç½‘约车全省总量表/订单分市州表（必须执行）
    sql_holiday.sql                          ä¸“项统计-重要节假日表（旧库缺表时执行）
    sql_holiday_decimal_migration.sql        èŠ‚假日数值列精度迁移（旧库升级）
    sql_holiday_comparison_base_migration.sql èŠ‚假日环比基期字段迁移（旧库升级）
  README-部署说明.txt

【部署机环境要求】
  JDK 8（必需）
  MySQL 5.7 / 8.0（必需）
  **不需要 Redis**（代码未使用；旧版说明里的 Redis æ˜¯é—留配置，可忽略）
  **不需要 nginx**（前端已内嵌进 jar，访问 8090 å³å¯ï¼›nginx ä»…为备选方案）

【部署步骤】
  1. åˆå§‹åŒ–数据库（4 ä¸ªè„šæœ¬éƒ½è¦æ‰§è¡Œï¼Œé¡ºåºå¦‚下）
       mysql --default-character-set=utf8mb4 -u root -p < db/init.sql
       mysql --default-character-set=utf8mb4 -u root -p traffic_audit < db/sql_city_bus.sql
       mysql --default-character-set=utf8mb4 -u root -p traffic_audit < db/sql_city_taxi.sql
       mysql --default-character-set=utf8mb4 -u root -p traffic_audit < db/sql_wyc.sql
     æ³¨ï¼šå…¨æ–°åº“çš„ init.sql å·²å«èŠ‚假日 4 å¼ è¡¨ï¼›è‹¥æ˜¯åœ¨æ—©æœŸç‰ˆæœ¬åº“上补节假日模块，再执行 db/sql_holiday.sql，并按需执行两个迁移脚本。
     é¢„置账号：admin / admin123（首次登录后请改密码）

  2. æ”¹é…ç½® backend/application.yml
     - spring.datasource.url / username / password ï¼šæ”¹æˆéƒ¨ç½²æœºçš„ MySQL（默认端口 3306）
     - jwt.secret ï¼šæ”¹æˆä¸€ä¸²éšæœºå­—符串（**必须是 Base64 åˆæ³•å­—符且长度是 4 çš„倍数**，如 32 ä½åå…­è¿›åˆ¶ï¼›å¡«ä¸­æ–‡ä¼šç™»å½•å¤±è´¥ï¼‰
     - deepseek.api-key ï¼šéœ€è¦ AI åˆ†æžæ—¶å¡«ï¼Œä¸éœ€è¦å¯ç•™ç©º
     æ³¨ï¼šapplication.yml ä¸Ž jar åŒçº§å³ç”Ÿæ•ˆï¼Œä¸ç”¨é‡æ–°æ‰“包。

  3. å¯åŠ¨åŽç«¯ï¼ˆåœ¨ backend ç›®å½•ä¸‹ï¼‰
     Windows：双击 start-backend.cmd
     Linux：  sh start-backend.sh
     æˆåŠŸæ ‡å¿—：出现 "Started TrafficAuditApplication" ä¸Ž "Tomcat started on port(s): 8090"

  4. è®¿é—®ç³»ç»Ÿ
     æµè§ˆå™¨æ‰“å¼€ http://<部署机IP>:8090  ï¼ˆå‰ç«¯å·²å†…嵌，页面与接口同源）
     è´¦å·ï¼šadmin / admin123

【数据迁移（可选）】
  æƒ³æŠŠæœ¬æœºæ•°æ®ä¸€å¹¶æ¬åˆ°æ–°æœºå™¨ï¼Œç”¨ mysqldump（本机 MySQL è‹¥ä¸åœ¨ 3306，按实际端口改）：
     mysqldump -h 127.0.0.1 -P 3306 -u root -p --databases traffic_audit > traffic_audit_full.sql
  å†åœ¨æ–°æœºå™¨æ‰§è¡Œï¼š
     mysql -u root -p < traffic_audit_full.sql
  æ³¨æ„ï¼šå…¨é‡ dump ä¼šå¸¦ä¸Šæœ¬æœºçš„账号密码，覆盖 init.sql é¢„置的 admin è´¦å·ã€‚

【常见问题】
  1. å¯åŠ¨æŠ¥ã€Œæœªæ‰¾åˆ°æ•°æ®ç›®å½• docs」/ å¯¼å‡ºæŠ¥ã€Œæœªæ‰¾åˆ°æ¨¡æ¿æ–‡ä»¶ã€ï¼š
     å¿…须在 backend ç›®å½•ä¸‹å¯åŠ¨ï¼ˆjar ä¸Ž docs åŒçº§ï¼‰ï¼Œä¸è¦åªæ‹· jar。
  2. æŠ¥è¡¨å¯¼å‡ºæŠ¥ã€Œæœªæ‰¾åˆ°æ±‡æ€»è¡¨æ¯ç‰ˆã€ŠYYYYå¹´M月道路运输量汇总表.xlsx》」：
     docs/生成汇总大表 ä¸‹ç¼ºå°‘该月份母版；把源机器的该文件拷过去。
  3. 8090 ç«¯å£è¢«å ç”¨ï¼šæ”¹ application.yml çš„ server.port åŽé‡å¯ã€‚
  4. é¡µé¢æ‰“开是空白：确认访问的是 http://<IP>:8090 æ ¹è·¯å¾„，且浏览器强制刷新（Ctrl+F5）。
  5. ä¸Šä¼ å¤§æ–‡ä»¶å¤±è´¥ï¼šåŽç«¯é™åˆ¶ 100MB，已配置；如前面还挂了 nginx，需同步放大 client_max_body_size。

【停止服务】
  Windows：关闭 start-backend.cmd çª—口
  Linux：  Ctrl+C，或 kill å¯¹åº” java è¿›ç¨‹ï¼ˆps -ef | grep java）

 deploy-templates/backend/application.yml

New file
@@ -0,0 +1,56 @@
# ============================================================
# TrafficAudit åŽç«¯å¤–部配置（与 jar åŒçº§å³å¯ç”Ÿæ•ˆï¼Œä¼˜å…ˆçº§é«˜äºŽ jar å†…置配置）
# éƒ¨ç½²åˆ°æ–°æœºå™¨åŽï¼Œè¯·**至少**修改下面标注 TODO çš„三处数据库配置！
# ============================================================
server:
  port: 8080
app:
  captcha:
    required: false        # ç”Ÿäº§çŽ¯å¢ƒå¦‚需图形验证码，改为 true
spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/traffic_audit?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai&useSSL=false&allowPublicKeyRetrieval=true&rewriteBatchedStatements=true
    username: root                     # TODO æ”¹æˆä½ çš„ MySQL è´¦å·
    password: è¯·æ”¹æˆä½ çš„数据库密码      # TODO æ”¹æˆä½ çš„ MySQL å¯†ç 
    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
mybatis-plus:
  mapper-locations: classpath*:/mapper/**/*.xml
  type-aliases-package: com.trafficaudit
  configuration:
    map-underscore-to-camel-case: true
  global-config:
    db-config:
      id-type: auto
      logic-delete-field: deleted
      logic-delete-value: 1
      logic-not-delete-value: 0
jwt:
  # å¿…须是「Base64 åˆæ³•å­—符 + é•¿åº¦æ˜¯ 4 çš„倍数」；下面这串 32 ä½åå…­è¿›åˆ¶å¯ç›´æŽ¥ç”¨ï¼Œ
  # ç”Ÿäº§çŽ¯å¢ƒå»ºè®®æ¢æˆè‡ªå·±çš„随机串（填中文或不合法字符会导致登录 500）
  secret: 8f2c1d64a7b34e09c5d81f6a2b0e7c93
  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/投资/模板
summary:
  template-dir: docs/生成汇总大表         # æ±‡æ€»å¤§è¡¨æ¯ç‰ˆä¸Žç‰ˆå¼å‚照件所在目录（必需）
deepseek:
  api-key: ""                          # AI åˆ†æžç”¨ï¼›ç•™ç©ºåˆ™ AI åˆ†æžä¸å¯ç”¨
  api-url: https://api.deepseek.com/v1/chat/completions
  model: deepseek-chat

 deploy-templates/backend/start-backend.cmd

New file
@@ -0,0 +1,16 @@
@echo off
chcp 65001 >nul
cd /d %~dp0
where java >nul 2>nul
if errorlevel 1 (
  echo [ERROR] æœªæ‰¾åˆ° java，请先安装 JDK 8 å¹¶åŠ å…¥ PATH
  pause
  exit /b 1
)
echo ============================================
echo  TrafficAudit å¯åŠ¨ä¸­ï¼šhttp://localhost:8090
echo  å‰ç«¯å·²å†…嵌，直接访问 8090 å³å¯ï¼ˆä¸éœ€è¦ nginx）
echo  æ—¥å¿—显示在本窗口，关闭窗口即停止服务
echo ============================================
java -jar traffic-audit-server-1.0.0-SNAPSHOT.jar
pause

 deploy-templates/backend/start-backend.sh

New file
@@ -0,0 +1,4 @@
#!/bin/sh
cd "$(dirname "$0")" || exit 1
echo "TrafficAudit å¯åŠ¨ä¸­ï¼šhttp://localhost:8090 ï¼ˆCtrl+C åœæ­¢ï¼‰"
java -jar traffic-audit-server-1.0.0-SNAPSHOT.jar 2>&1 | tee app.log

 deploy-templates/db/init.sql

New file
@@ -0,0 +1,687 @@
-- äº¤é€šç»Ÿè®¡æŠ¥è¡¨å®¡æ ¸ç³»ç»Ÿ - æ•°æ®åº“初始化脚本 v3
-- Demo范围：交企统H203-2表_道路货物运输月度生产情况

CREATE DATABASE IF NOT EXISTS traffic_audit DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;
USE traffic_audit;

-- ============================================
-- ä¸€ã€ç”¨æˆ·æƒé™æ¨¡å—（含三员）
-- ============================================

-- éƒ¨é—¨è¡¨
DROP TABLE IF EXISTS sys_dept;
CREATE TABLE sys_dept (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    dept_name VARCHAR(100) NOT NULL COMMENT '部门名称',
    dept_code VARCHAR(20) NOT NULL COMMENT '行政区划代码',
    parent_id BIGINT DEFAULT 0 COMMENT '上级部门',
    dept_level TINYINT COMMENT '1省 2市 3县',
    sort_order INT DEFAULT 0
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- è§’色表
DROP TABLE IF EXISTS sys_role;
CREATE TABLE sys_role (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    role_name VARCHAR(50) NOT NULL COMMENT '角色名',
    role_code VARCHAR(50) NOT NULL COMMENT 'SYS_ADMIN/SEC_OFFICER/AUDITOR/PROVINCE/CITY/COUNTY',
    role_type VARCHAR(20) DEFAULT 'BUSINESS' COMMENT 'SYSTEM(三员)/BUSINESS(业务)',
    role_level TINYINT DEFAULT 1 COMMENT '0三员 1省厅 2市局 3县区',
    is_mutex TINYINT DEFAULT 0 COMMENT '1三员互斥 0普通'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- ç”¨æˆ·è¡¨
DROP TABLE IF EXISTS sys_user;
CREATE TABLE sys_user (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    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启用',
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- ç”¨æˆ·è§’色关联
DROP TABLE IF EXISTS sys_user_role;
CREATE TABLE sys_user_role (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    user_id BIGINT NOT NULL,
    role_id BIGINT NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- ============================================
-- äºŒã€ä¸šåŠ¡æ•°æ®æ¨¡å—
-- ============================================

-- æ¸…理旧版遗留表（v2 schema）
DROP TABLE IF EXISTS report_enterprise_monthly;

-- äº¤ä¼ç»ŸH203-2表：道路货物运输月度生产情况（Demo核心表）
DROP TABLE IF EXISTS h2032_enterprise_monthly;
CREATE TABLE h2032_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 '企业名称',
    unified_credit_code VARCHAR(50) COMMENT '统一社会信用代码',
    report_unit VARCHAR(200) COMMENT '填报单位',

    -- è½¦è¾†æ•°ä¸Žå¨ä½æ•°
    vehicle_total INT COMMENT '车辆数_总计',
    tons_total DOUBLE COMMENT '标记吨位数_总计',
    vehicle_tractor INT COMMENT '车辆数_牵引车',
    vehicle_trailer INT COMMENT '车辆数_挂车',
    tons_trailer DOUBLE COMMENT '标记吨位数_挂车',
    vehicle_container INT COMMENT '车辆数_集装箱车',
    tons_container DOUBLE COMMENT '标记吨位数_集装箱车',
    vehicle_whole INT COMMENT '车辆数_整车',
    tons_whole DOUBLE COMMENT '标记吨位数_整车',

    -- è´§è¿é‡ä¸Žå‘¨è½¬é‡
    freight_total DOUBLE COMMENT '货运量_总计（吨）',
    turnover_total DOUBLE COMMENT '货物周转量_总计（吨公里）',

    -- åˆ†è´§ç±»è´§è¿é‡
    freight_container DOUBLE COMMENT '货运量_集装箱（吨）',
    freight_coal DOUBLE COMMENT '货运量_煤炭及制品（吨）',
    freight_oil_gas DOUBLE COMMENT '货运量_石油天然气及制品（吨）',
    freight_crude_oil DOUBLE COMMENT '货运量_其中原油（吨）',
    freight_metal_ore DOUBLE COMMENT '货运量_金属矿石（吨）',
    freight_iron_ore DOUBLE COMMENT '货运量_其中铁矿石（吨）',
    freight_building DOUBLE COMMENT '货运量_矿物性建筑材料（吨）',
    freight_grain DOUBLE COMMENT '货运量_粮食（吨）',

    -- è¿è¥æŒ‡æ ‡
    avg_tonnage DOUBLE COMMENT '货车平均吨位',
    avg_tonnage_trailer DOUBLE COMMENT '平均吨位_挂车',
    avg_tonnage_whole DOUBLE COMMENT '平均吨位_整车',
    avg_distance DOUBLE COMMENT '货车平均运距（公里）',
    daily_trips_per_ton DOUBLE COMMENT '单吨日均载运次数',
    daily_mileage_per_vehicle DOUBLE COMMENT '单车单天行驶里程（公里）',
    daily_volume_per_vehicle DOUBLE COMMENT '单车日均运量（吨）',
    daily_trips_with_tractor DOUBLE COMMENT '单吨日均载运次数（结合牵引车）',

    -- çŽ¯æ¯”增速
    vehicle_mom_growth DOUBLE COMMENT '车辆数-总计环比增速',
    tons_mom_growth DOUBLE COMMENT '标记吨位-总计环比增速',
    freight_mom_growth DOUBLE COMMENT '货运量-总计环比增速',
    turnover_mom_growth DOUBLE COMMENT '货物周转量-总计环比增速',
    avg_distance_mom_growth DOUBLE COMMENT '货车平均运距-环比增速',

    -- åŒæ¯”增速
    vehicle_yoy_growth DOUBLE COMMENT '车辆数-总计同比增速',
    tons_yoy_growth DOUBLE COMMENT '标记吨位-总计同比增速',
    tractor_trailer_ratio DOUBLE COMMENT '牵引车挂车比',
    freight_yoy_growth DOUBLE COMMENT '货运量-总计同比增速',
    turnover_yoy_growth DOUBLE COMMENT '货物周转量-总计同比增速',
    avg_distance_yoy_growth DOUBLE COMMENT '货车平均运距-同比增速',

    -- å¡«æŠ¥ä¿¡æ¯
    unit_leader VARCHAR(50) COMMENT '单位负责人',
    stats_leader VARCHAR(50) COMMENT '统计负责人',
    contact_person VARCHAR(50) COMMENT '填表人',
    contact_phone VARCHAR(20) COMMENT '联系电话',
    report_date DATE COMMENT '报出日期',
    verify_explanation TEXT COMMENT '核实性原因解释',
    report_notes TEXT COMMENT '上报说明',
    modify_record TEXT COMMENT '修改记录',

    import_batch_id BIGINT COMMENT '导入批次',
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='交企统H203-2表_道路货物运输月度生产情况';

-- è¿æ”¿è½¦è¾†æ•°æ®
DROP TABLE IF EXISTS transport_auth_vehicle;
CREATE TABLE transport_auth_vehicle (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    report_period VARCHAR(20) COMMENT '报表期',
    enterprise_name VARCHAR(200) COMMENT '企业名称',
    tractor_count INT DEFAULT 0 COMMENT '总牵引车数',
    trailer_count INT DEFAULT 0 COMMENT '总挂车数',
    other_count INT DEFAULT 0 COMMENT '其它车辆数',
    trailer_tons DOUBLE COMMENT '挂车总吨位(吨)',
    other_tons DOUBLE COMMENT '其它车辆总吨位(吨)',
    import_batch_id BIGINT COMMENT '导入批次',
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='运政车辆数据';

-- è½¦è¾†è½¨è¿¹é‡Œç¨‹æ•°æ®
DROP TABLE IF EXISTS vehicle_track_mileage;
CREATE TABLE vehicle_track_mileage (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    enterprise_name VARCHAR(200) COMMENT '企业名称',
    monthly_mileage DOUBLE COMMENT '月度总里程(公里)',
    tracked_vehicles INT DEFAULT 0 COMMENT '有里程的车辆数',
    report_period VARCHAR(20) COMMENT '报表期',
    import_batch_id BIGINT COMMENT '导入批次',
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='车辆轨迹里程数据';

-- è§„上规下拆分运输量（用户手动上传）
DROP TABLE IF EXISTS scale_split_transport;
CREATE TABLE scale_split_transport (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    report_period VARCHAR(20) NOT NULL COMMENT '报表期 2026-06',
    period_type VARCHAR(10) NOT NULL COMMENT 'MONTH当月/CUMULATIVE累计',
    region_name VARCHAR(50) COMMENT '市州名称',

    -- è§„上
    above_scale_freight DOUBLE COMMENT '规上货运量',
    above_scale_turnover DOUBLE COMMENT '规上周转量',
    above_scale_rank INT COMMENT '规上排名',
    above_scale_yoy DOUBLE COMMENT '规上同比',
    above_scale_yoy_rank INT COMMENT '规上增速排名',

    -- è§„下
    below_scale_freight DOUBLE COMMENT '规下货运量',
    below_scale_turnover DOUBLE COMMENT '规下周转量',
    below_scale_rank INT COMMENT '规下排名',
    below_scale_yoy DOUBLE COMMENT '规下同比',
    below_scale_yoy_rank INT COMMENT '规下增速排名',

    -- åˆè®¡
    total_freight DOUBLE COMMENT '运输量合计-货运量',
    total_turnover DOUBLE COMMENT '运输量合计-周转量',
    total_rank INT COMMENT '合计排名',
    total_yoy DOUBLE COMMENT '合计同比',
    total_yoy_rank INT COMMENT '合计增速排名',

    import_batch_id BIGINT COMMENT '导入批次',
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='规上规下拆分运输量';

-- æ¨¡æ¿_货运量周转量（每月导入：左半今年1-N月，右半去年1-12月，N=报表期月份）
DROP TABLE IF EXISTS freight_turnover_import;
CREATE TABLE freight_turnover_import (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    report_period VARCHAR(20) NOT NULL COMMENT '报表期 2026-06',
    region_name VARCHAR(50) NOT NULL COMMENT '市州或湖北省',

    -- ä»Šå¹´1-12月货运量（左半，仅1-N月有值）
    freight_m01 DOUBLE COMMENT '1月货运量(万吨)',
    freight_m02 DOUBLE COMMENT '2月货运量(万吨)',
    freight_m03 DOUBLE COMMENT '3月货运量(万吨)',
    freight_m04 DOUBLE COMMENT '4月货运量(万吨)',
    freight_m05 DOUBLE COMMENT '5月货运量(万吨)',
    freight_m06 DOUBLE COMMENT '6月货运量(万吨)',
    freight_m07 DOUBLE COMMENT '7月货运量(万吨)',
    freight_m08 DOUBLE COMMENT '8月货运量(万吨)',
    freight_m09 DOUBLE COMMENT '9月货运量(万吨)',
    freight_m10 DOUBLE COMMENT '10月货运量(万吨)',
    freight_m11 DOUBLE COMMENT '11月货运量(万吨)',
    freight_m12 DOUBLE COMMENT '12月货运量(万吨)',

    -- åŽ»å¹´1-12月货运量（右半，固定12个月，算同比用）
    last_freight_m01 DOUBLE COMMENT '去年1月货运量(万吨)',
    last_freight_m02 DOUBLE COMMENT '去年2月货运量(万吨)',
    last_freight_m03 DOUBLE COMMENT '去年3月货运量(万吨)',
    last_freight_m04 DOUBLE COMMENT '去年4月货运量(万吨)',
    last_freight_m05 DOUBLE COMMENT '去年5月货运量(万吨)',
    last_freight_m06 DOUBLE COMMENT '去年6月货运量(万吨)',
    last_freight_m07 DOUBLE COMMENT '去年7月货运量(万吨)',
    last_freight_m08 DOUBLE COMMENT '去年8月货运量(万吨)',
    last_freight_m09 DOUBLE COMMENT '去年9月货运量(万吨)',
    last_freight_m10 DOUBLE COMMENT '去年10月货运量(万吨)',
    last_freight_m11 DOUBLE COMMENT '去年11月货运量(万吨)',
    last_freight_m12 DOUBLE COMMENT '去年12月货运量(万吨)',

    -- ä»Šå¹´1-12月周转量（左半，仅1-N月有值，导入存档，报表用拆分表）
    turnover_m01 DOUBLE COMMENT '1月周转量(万吨公里)',
    turnover_m02 DOUBLE COMMENT '2月周转量(万吨公里)',
    turnover_m03 DOUBLE COMMENT '3月周转量(万吨公里)',
    turnover_m04 DOUBLE COMMENT '4月周转量(万吨公里)',
    turnover_m05 DOUBLE COMMENT '5月周转量(万吨公里)',
    turnover_m06 DOUBLE COMMENT '6月周转量(万吨公里)',
    turnover_m07 DOUBLE COMMENT '7月周转量(万吨公里)',
    turnover_m08 DOUBLE COMMENT '8月周转量(万吨公里)',
    turnover_m09 DOUBLE COMMENT '9月周转量(万吨公里)',
    turnover_m10 DOUBLE COMMENT '10月周转量(万吨公里)',
    turnover_m11 DOUBLE COMMENT '11月周转量(万吨公里)',
    turnover_m12 DOUBLE COMMENT '12月周转量(万吨公里)',

    -- åŽ»å¹´1-12月周转量（右半，固定12个月）
    last_turnover_m01 DOUBLE COMMENT '去年1月周转量(万吨公里)',
    last_turnover_m02 DOUBLE COMMENT '去年2月周转量(万吨公里)',
    last_turnover_m03 DOUBLE COMMENT '去年3月周转量(万吨公里)',
    last_turnover_m04 DOUBLE COMMENT '去年4月周转量(万吨公里)',
    last_turnover_m05 DOUBLE COMMENT '去年5月周转量(万吨公里)',
    last_turnover_m06 DOUBLE COMMENT '去年6月周转量(万吨公里)',
    last_turnover_m07 DOUBLE COMMENT '去年7月周转量(万吨公里)',
    last_turnover_m08 DOUBLE COMMENT '去年8月周转量(万吨公里)',
    last_turnover_m09 DOUBLE COMMENT '去年9月周转量(万吨公里)',
    last_turnover_m10 DOUBLE COMMENT '去年10月周转量(万吨公里)',
    last_turnover_m11 DOUBLE COMMENT '去年11月周转量(万吨公里)',
    last_turnover_m12 DOUBLE COMMENT '去年12月周转量(万吨公里)',

    import_batch_id BIGINT COMMENT '导入批次',
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='模板_货运量周转量导入';

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

DROP TABLE IF EXISTS audit_rule;
CREATE TABLE audit_rule (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    rule_name VARCHAR(100) NOT NULL COMMENT '规则名称',
    rule_code VARCHAR(50) NOT NULL COMMENT '规则编码',
    description TEXT COMMENT '规则描述',
    check_field VARCHAR(200) COMMENT '检查字段',
    compare_type VARCHAR(20) COMMENT 'DIFF/RATIO/MOM/YOY/NULL_CHECK/RANGE',
    threshold VARCHAR(50) COMMENT '阈值',
    alert_level VARCHAR(10) DEFAULT 'YELLOW' COMMENT 'RED/YELLOW',
    report_type VARCHAR(50) DEFAULT 'H2032' COMMENT '适用报表表号',
    is_enabled TINYINT DEFAULT 1,
    llm_raw_input TEXT COMMENT 'LLM翻译原始输入',
    sort_order INT DEFAULT 0,
    created_by BIGINT,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- é¢„ç½®6条审核规则（Demo）
INSERT INTO audit_rule (rule_name, rule_code, description, check_field, compare_type, threshold, alert_level, report_type, is_enabled, sort_order) VALUES
('车辆数运政对比', '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,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);

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

DROP TABLE IF EXISTS audit_result;
CREATE TABLE audit_result (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    rule_id BIGINT NOT NULL COMMENT 'FK -> audit_rule',
    report_id BIGINT NOT NULL COMMENT 'FK -> h2032_enterprise_monthly',
    enterprise_code VARCHAR(50) COMMENT '企业代码',
    report_period VARCHAR(20) COMMENT '报表期',
    actual_value VARCHAR(200) COMMENT '实际值',
    threshold_value VARCHAR(200) COMMENT '阈值',
    deviation VARCHAR(200) COMMENT '偏差',
    status VARCHAR(20) DEFAULT 'PENDING' COMMENT 'PENDING/CONFIRMED/IGNORED',
    reviewer_id BIGINT COMMENT '审核人',
    review_comment TEXT COMMENT '审核意见',
    reviewed_at DATETIME,
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

DROP TABLE IF EXISTS audit_explanation;
CREATE TABLE audit_explanation (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    audit_result_id BIGINT NOT NULL COMMENT 'FK -> audit_result',
    explanation_text TEXT COMMENT '上报人解释',
    llm_suggestion TEXT COMMENT 'LLM建议',
    llm_confidence DECIMAL(5,2) COMMENT '置信度',
    llm_status VARCHAR(20) DEFAULT 'PENDING' COMMENT 'PENDING/PROCESSED/FAILED'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- ============================================
-- äº”、系统日志与导入批次
-- ============================================

DROP TABLE IF EXISTS sys_operation_log;
CREATE TABLE sys_operation_log (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    user_id BIGINT COMMENT '操作人',
    module VARCHAR(50) COMMENT '模块',
    action VARCHAR(50) COMMENT '操作',
    detail TEXT COMMENT '详情JSON',
    ip_address VARCHAR(50) COMMENT 'IP地址',
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

DROP TABLE IF EXISTS import_batch;
CREATE TABLE import_batch (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    file_name VARCHAR(200) COMMENT '文件名',
    import_type VARCHAR(50) COMMENT 'H2032/TRANSPORT_AUTH/TRACK_MILEAGE/SCALE_SPLIT',
    report_period VARCHAR(20) COMMENT '报表期',
    total_rows INT DEFAULT 0,
    success_rows INT DEFAULT 0,
    fail_rows INT DEFAULT 0,
    error_detail TEXT COMMENT '错误详情',
    created_by BIGINT COMMENT '导入人',
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- ============================================
-- å…­ã€LLM脱敏映射
-- ============================================

DROP TABLE IF EXISTS llm_desensitize_map;
CREATE TABLE llm_desensitize_map (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    original_value VARCHAR(200) COMMENT '原始值',
    masked_value VARCHAR(200) COMMENT '脱敏值',
    mask_type VARCHAR(20) COMMENT 'ENTERPRISE/REGION',
    call_id VARCHAR(50) COMMENT '调用ID'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

-- ============================================
-- ä¸ƒã€é¢„置数据
-- ============================================

-- é¢„置部门（湖北省）
INSERT INTO sys_dept (dept_name, dept_code, dept_level) VALUES ('湖北省交通运输厅', '420000', 1);

-- é¢„置角色
INSERT INTO sys_role (role_name, role_code, role_type, role_level, is_mutex) VALUES
('系统管理员', 'SYS_ADMIN', 'SYSTEM', 0, 1),
('安全保密员', 'SEC_OFFICER', 'SYSTEM', 0, 1),
('安全审计员', 'AUDITOR', 'SYSTEM', 0, 1),
('省厅业务员', 'PROVINCE', 'BUSINESS', 1, 0);

-- é¢„置管理员账号 admin / admin123
INSERT INTO sys_user (username, password, real_name, dept_id) VALUES
('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 '企业名称',
    unified_credit_code VARCHAR(50) COMMENT '统一社会信用代码',
    report_unit 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),
('平均运距环比超±20%核实', 'RULE_P005', '一类/二类/三类/四类平均运距环比上个月超过±20%需核实', 'avgDistanceClass1,avgDistanceClass2,avgDistanceClass3,avgDistanceClass4', 'MOM_PCT', '20', '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='报表期审核通过标记';


-- ============================================
-- åä¸€ã€ä¸“项统计-重要节假日
-- ============================================

-- èŠ‚假日日期配置
DROP TABLE IF EXISTS holiday_calendar;
CREATE TABLE holiday_calendar (
  id BIGINT NOT NULL AUTO_INCREMENT,
  year INT NOT NULL COMMENT '年份',
  holiday_type VARCHAR(32) NOT NULL COMMENT '节假日分类：SPRING_FESTIVAL/LABOR_DAY/NATIONAL_DAY',
  holiday_date DATE NOT NULL COMMENT '节假日具体日期',
  day_index INT NOT NULL COMMENT '第几日，从 1 å¼€å§‹',
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (id),
  UNIQUE KEY uk_holiday_calendar_seq (year, holiday_type, day_index),
  UNIQUE KEY uk_holiday_calendar_date (year, holiday_type, holiday_date),
  KEY idx_holiday_calendar_date (holiday_date)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='重要节假日日期配置';

-- èŠ‚假日综合运输营业性客流
DROP TABLE IF EXISTS holiday_passenger_flow;
CREATE TABLE holiday_passenger_flow (
  id BIGINT NOT NULL AUTO_INCREMENT,
  year INT NOT NULL COMMENT '年份',
  flow_date DATE NOT NULL COMMENT '日期',
  transport_mode VARCHAR(32) NOT NULL COMMENT '运输方式：RAIL/CIVIL_AVIATION/ROAD/WATER',
  passenger_count DECIMAL(30,15) NOT NULL COMMENT '发送旅客数（万人次）',
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (id),
  UNIQUE KEY uk_holiday_passenger (year, flow_date, transport_mode),
  KEY idx_holiday_passenger_date (flow_date)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='节假日综合运输营业性客流情况';

-- èŠ‚假日综合运输非营业性车流
DROP TABLE IF EXISTS holiday_vehicle_flow;
CREATE TABLE holiday_vehicle_flow (
  id BIGINT NOT NULL AUTO_INCREMENT,
  year INT NOT NULL COMMENT '年份',
  flow_date DATE NOT NULL COMMENT '日期',
  road_category VARCHAR(32) NOT NULL COMMENT '道路分类：EXPRESSWAY/NATIONAL_PROVINCIAL',
  vehicle_type VARCHAR(32) NOT NULL COMMENT '车型分类：SMALL_PASSENGER/MEDIUM_SMALL_PASSENGER',
  vehicle_count DECIMAL(30,15) NOT NULL COMMENT '车流量（万辆次）',
  comparison_base DECIMAL(30,15) NULL COMMENT '普通国省道环比基期（万辆次，仅当年使用）',
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (id),
  UNIQUE KEY uk_holiday_vehicle (year, flow_date, road_category, vehicle_type),
  KEY idx_holiday_vehicle_date (flow_date)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='节假日综合运输非营业性车流情况';

-- å®¢è¿ç³»æ•°é…ç½®
DROP TABLE IF EXISTS holiday_passenger_coefficient;
CREATE TABLE holiday_passenger_coefficient (
  id BIGINT NOT NULL AUTO_INCREMENT,
  year INT NOT NULL COMMENT '年份',
  date_category VARCHAR(32) NOT NULL COMMENT '日期分类：HOLIDAY/NON_HOLIDAY',
  coefficient DECIMAL(30,15) NOT NULL COMMENT '客运系数',
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (id),
  UNIQUE KEY uk_holiday_coefficient (year, date_category)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='客运系数配置';

 deploy-templates/db/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);

 deploy-templates/db/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);

 deploy-templates/db/sql_holiday.sql

New file
@@ -0,0 +1,53 @@
-- Holiday statistics module. Run against the traffic_audit database.
CREATE TABLE IF NOT EXISTS holiday_calendar (
  id BIGINT NOT NULL AUTO_INCREMENT,
  year INT NOT NULL,
  holiday_type VARCHAR(32) NOT NULL,
  holiday_date DATE NOT NULL,
  day_index INT NOT NULL,
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (id),
  UNIQUE KEY uk_holiday_calendar_seq (year, holiday_type, day_index),
  UNIQUE KEY uk_holiday_calendar_date (year, holiday_type, holiday_date),
  KEY idx_holiday_calendar_date (holiday_date)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE IF NOT EXISTS holiday_passenger_flow (
  id BIGINT NOT NULL AUTO_INCREMENT,
  year INT NOT NULL,
  flow_date DATE NOT NULL,
  transport_mode VARCHAR(32) NOT NULL,
  passenger_count DECIMAL(30,15) NOT NULL,
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (id),
  UNIQUE KEY uk_holiday_passenger (year, flow_date, transport_mode),
  KEY idx_holiday_passenger_date (flow_date)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE IF NOT EXISTS holiday_vehicle_flow (
  id BIGINT NOT NULL AUTO_INCREMENT,
  year INT NOT NULL,
  flow_date DATE NOT NULL,
  road_category VARCHAR(32) NOT NULL,
  vehicle_type VARCHAR(32) NOT NULL,
  vehicle_count DECIMAL(30,15) NOT NULL,
  comparison_base DECIMAL(30,15) NULL COMMENT '普通国省道环比基期（万辆次，仅当年使用）',
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (id),
  UNIQUE KEY uk_holiday_vehicle (year, flow_date, road_category, vehicle_type),
  KEY idx_holiday_vehicle_date (flow_date)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE IF NOT EXISTS holiday_passenger_coefficient (
  id BIGINT NOT NULL AUTO_INCREMENT,
  year INT NOT NULL,
  date_category VARCHAR(32) NOT NULL,
  coefficient DECIMAL(30,15) NOT NULL,
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (id),
  UNIQUE KEY uk_holiday_coefficient (year, date_category)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

 deploy-templates/db/sql_holiday_comparison_base_migration.sql

New file
@@ -0,0 +1,6 @@
-- Add the optional ordinary national/provincial road comparison base.
-- The field is used only for the 2026 holiday data.
ALTER TABLE holiday_vehicle_flow
  ADD COLUMN comparison_base DECIMAL(30,15) NULL
  COMMENT '普通国省道环比基期（万辆次，仅当年使用）'
  AFTER vehicle_count;

 deploy-templates/db/sql_holiday_decimal_migration.sql

New file
@@ -0,0 +1,16 @@
-- Convert holiday statistics numeric columns from binary floating point to exact decimal storage.
-- Run once against the traffic_audit database.
ALTER TABLE holiday_passenger_flow
  MODIFY COLUMN passenger_count DECIMAL(30,15) NOT NULL COMMENT '发送旅客数（万人次）';

ALTER TABLE holiday_vehicle_flow
  MODIFY COLUMN vehicle_count DECIMAL(30,15) NOT NULL COMMENT '车流量（万辆次）';

ALTER TABLE holiday_passenger_coefficient
  MODIFY COLUMN coefficient DECIMAL(30,15) NOT NULL COMMENT '客运系数';

-- The seeded coefficient was averaged from repeated 2.4 cells through a Java double.
-- Normalize the migrated value to the exact Excel decimal.
UPDATE holiday_passenger_coefficient
SET coefficient = 2.4
WHERE year IN (2024, 2025, 2026);

 deploy-templates/db/sql_wyc.sql

New file
@@ -0,0 +1,45 @@
-- åŸŽå¸‚客运网约车月度输入建表（2026-09-04）
-- æ•°æ®æº1：模板_网约车总数.xlsx（月度全省 pin：客运量/其中城市内/周转量/其中城市内周转量）
-- æ•°æ®æº2：模板_网约车订单及全省总量.xlsx（月度输入页：B-E å…¨çœ pin + F è®¢å•åˆè®¡ + G-W 17市州订单）

CREATE TABLE IF NOT EXISTS wyc_total_monthly (
  id BIGINT NOT NULL AUTO_INCREMENT,
  report_period VARCHAR(20) NOT NULL COMMENT '报表期 yyyy-MM',
  pin_k DOUBLE DEFAULT NULL COMMENT '全省网约车客运量(万人次)',
  pin_ck DOUBLE DEFAULT NULL COMMENT '其中城市内客运量',
  pin_z DOUBLE DEFAULT NULL COMMENT '全省客运周转量(万人公里)',
  pin_cz DOUBLE DEFAULT NULL COMMENT '其中城市内周转量',
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (id),
  UNIQUE KEY uk_wyc_total_period (report_period)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='网约车月度全省 pin è¾“å…¥';

CREATE TABLE IF NOT EXISTS wyc_order_monthly (
  id BIGINT NOT NULL AUTO_INCREMENT,
  report_period VARCHAR(20) NOT NULL COMMENT '报表期 yyyy-MM',
  pin_k DOUBLE DEFAULT NULL,
  pin_ck DOUBLE DEFAULT NULL,
  pin_z DOUBLE DEFAULT NULL,
  pin_cz DOUBLE DEFAULT NULL,
  order_sum DOUBLE DEFAULT NULL COMMENT '订单合计（单）',
  order_wuhan DOUBLE DEFAULT NULL,
  order_huangshi DOUBLE DEFAULT NULL,
  order_shiyan DOUBLE DEFAULT NULL,
  order_yichang DOUBLE DEFAULT NULL,
  order_xiangyang DOUBLE DEFAULT NULL,
  order_ezhou DOUBLE DEFAULT NULL,
  order_jingmen DOUBLE DEFAULT NULL,
  order_xiaogan DOUBLE DEFAULT NULL,
  order_jingzhou DOUBLE DEFAULT NULL,
  order_huanggang DOUBLE DEFAULT NULL,
  order_xianning DOUBLE DEFAULT NULL,
  order_suizhou DOUBLE DEFAULT NULL,
  order_enshi DOUBLE DEFAULT NULL,
  order_xiantao DOUBLE DEFAULT NULL,
  order_qianjiang DOUBLE DEFAULT NULL,
  order_tianmen DOUBLE DEFAULT NULL,
  order_shennong DOUBLE DEFAULT NULL,
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (id),
  UNIQUE KEY uk_wyc_order_period (report_period)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='网约车订单及全省总量月度输入';

 deploy-templates/frontend/nginx.conf.example

New file
@@ -0,0 +1,15 @@
# å‰ç«¯ nginx é…ç½®ç¤ºä¾‹ï¼ˆåªæœ‰åœ¨ä¸æƒ³ç”¨ã€Œjar å†…嵌前端」时才需要）
server {
    listen       8080;
    server_name  localhost;
    root   /opt/traffic-audit/frontend/dist;   # æ”¹æˆå®žé™…路径
    index  index.html;
    location /api/ {
        proxy_pass http://127.0.0.1:8090;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_read_timeout 300s;
    }
    location / { try_files $uri $uri/ /index.html; }
}

 docs/Excel¸¡µãÊý´æ´¢.txt

New file
@@ -0,0 +1,152 @@
excel的数值计算非常精确，其内部是怎么存储数值的呢，是用浮点数吗
用户想知道Excel内部如何存储数值，是否使用浮点数。我需要提供准确的解释。为了全面获取信息，我将同时进行多项搜索，覆盖Excel数值存储机制、浮点数精度问题、与IEEE 754标准的关系以及可能的优化技术。

搜索到 16 ä¸ªç½‘页
搜索结果显示了一些相关页面。为了全面获取信息，我们需要同时打开这些页面。

浏览 1 ä¸ªé¡µé¢
Floating Point Errors in Excel
这些资料提供了关于Excel数值存储的详细信息。微软的文档明确指出Excel遵循IEEE 754标准，使用双精度浮点数，有效数字为15位。Stack Overflow的讨论也确认了这一点。ExcelJet的文章解释了浮点数误差的原因。我的回答将涵盖以下几个方面：Excel使用IEEE 754双精度浮点数（64位），有效精度为15位，存储范围，以及浮点数误差及其原因。我还会提及一些特殊情况，比如整数存储和日期时间存储。为了更全面地覆盖这些方面，我需要同时进行多项搜索。

搜索到 12 ä¸ªç½‘页
现在可以组织答案了。答案将涵盖：Excel使用IEEE 754双精度浮点数（64位），有效精度为15位，存储范围，以及浮点数误差及其原因。还会提及整数和日期时间的存储方式。回答时会引用微软文档、Stack Overflow等来源。

是的，Excel çš„数值计算确实基于浮点数，具体来说，它遵循 IEEE 754 æ ‡å‡†çš„ 64 ä½åŒç²¾åº¦æµ®ç‚¹æ•°æ ¼å¼æ¥å­˜å‚¨å’Œè®¡ç®—数值。

核心机制：64位双精度浮点数
Excel å†…部将所有工作表单元格中的数字（包括整数、日期和时间）都统一存储为 8字节（64位）的双精度浮点数。

这种存储格式的 64 ä¸ªæ¯”特位被划分为三个部分：

符号位 (1位)：表示正负。

指数位 (11位)：决定数值的范围。

尾数位 (52位)：决定数值的精度。

精度限制：15位有效数字
尽管双精度浮点数能提供约 15 åˆ° 16 ä½çš„十进制有效数字，但 Excel ä¸ºäº†ç¡®ä¿è®¡ç®—结果的可靠性，将有效精度限制在 15 ä½ã€‚

这意味着，如果一个数字的有效位数超过 15 ä½ï¼Œä»Žç¬¬ 16 ä½å¼€å§‹å°†è¢«æ›¿æ¢ä¸º 0。例如，输入 123456789012345678，Excel å®žé™…存储的将是 123456789012345000。

数值范围
基于此标准，Excel å¯ä»¥å¤„理的数值范围如下：

最大正数：1.79769313486232E+308

最小正数：2.2250738585072E-308

超出此范围的数值会被视为“无穷大”并显示为错误值。

为什么会有浮点数误差？
你可能会遇到 Excel è®¡ç®— 0.1 + 0.2 å¾—到 0.30000000000000004 çš„情况，这并非 Bug，而是二进制浮点数的固有特性。

其根本原因在于，像 0.1 è¿™æ ·çš„十进制小数无法用二进制浮点数精确表示，就像十进制无法精确表示 1/3 ä¸€æ ·ã€‚Excel å­˜å‚¨çš„是一个极其接近 0.1 çš„近似值，当多个这样的近似值进行运算时，微小的误差会累积，最终导致结果出现极小的偏差。

其他数据类型的存储
整数：也按双精度浮点数存储，因此 Excel èƒ½ç²¾ç¡®è¡¨ç¤ºçš„整数上限是 2^53（约 9,007,199,254,740,992）。超过此范围的整数可能会丢失精度。

日期和时间：同样是浮点数。整数部分代表日期（自 1900 å¹´ 1 æœˆ 1 æ—¥ä»¥æ¥çš„天数），小数部分代表时间（一天中的比例）。

总结来说，Excel çš„数值计算在底层就是标准的 IEEE 754 åŒç²¾åº¦æµ®ç‚¹æ•°ï¼Œå…¶â€œç²¾ç¡®â€æ˜¯ç›¸å¯¹çš„，受限于 15 ä½æœ‰æ•ˆæ•°å­—的精度和二进制浮点数本身的表示限制。

那么用Java处理excel的数据时，为了保持与excel的计算结果一致，数据库和Java中如何存储和计算呢
用户想知道如何在Java中处理Excel数据，以保持与Excel计算结果一致，涉及数据库和Java中的存储与计算。我需要提供关于数据类型选择、计算策略以及可能遇到的精度问题方面的建议。为了全面获取信息，我将同时进行多项搜索，覆盖Java处理Excel精度、数据库存储策略、BigDecimal使用、Apache POI处理方式以及IEEE 754兼容性等关键方面。

搜索到 36 ä¸ªç½‘页
搜索结果显示了一些相关资源。为了全面获取信息，我们需要同时打开这些结果。

浏览 4 ä¸ªé¡µé¢
NumberComparer (POI API Documentation)
EasyExcel读入数字类型数据时出现小数位增长现象 - EasyExcel读入数字类型数据时出现小数位增长现象
【完美解决POI读取Excel文档数值类型缺失精度问题】
MySQL :: MySQL 9.0 åƒè€ƒæ‰‹å†Š :: 13.1.3 å®šé»žé¡žåž‹ï¼ˆç²¾ç¢ºå€¼ï¼‰- DECIMAL、NUMERIC
这些资料提供了关于精度问题、Apache POI的NumberToTextConverter、Excel的15位精度限制以及数据库DECIMAL类型的信息。我的回答将涵盖Java中的存储与计算、数据库中的存储、以及如何保持结果一致。回答会引用这些资料。现在开始组织回答。

要在Java中处理Excel数据并保持结果一致，核心思路是将Excel的15位有效数字精度作为基准，在Java和数据库中采用更高精度或精确类型进行存储，并统一计算与舍入规则。

💾 ç¬¬ä¸€æ­¥ï¼šåœ¨Java中如何存储与读取
Java的 double ç±»åž‹åŒæ ·éµå¾ª IEEE 754 æ ‡å‡†ï¼Œä½†å…¶æœ‰æ•ˆæ•°å­—可达15-17位，而Excel严格限制为15位，这是差异的根源。

读取时：推荐用 BigDecimal æˆ– String

直接用 double æŽ¥æ”¶ Excel æ•°å€¼ä¼šå¼•å…¥é¢å¤–的二进制浮点误差。例如，Excel ä¸­çš„ 9699.1 è¯»æˆ double å¯èƒ½å˜æˆ 9699.0999999999999996。

推荐方案：

读取为 BigDecimal：在实体类中，将金额、数量等数值字段声明为 BigDecimal ç±»åž‹ï¼Œè€Œéž double æˆ– float。

使用 POI çš„ NumberToTextConverter：Apache POI æä¾›äº† NumberToTextConverter.toText(double) å·¥å…·ç±»ï¼Œå¯ä»¥å°† Excel çš„原始数值精确地转换为字符串，再由字符串构造 BigDecimal，避免中间精度损失。

java
import org.apache.poi.ss.util.NumberToTextConverter;
import java.math.BigDecimal;

if (cell.getCellType() == CellType.NUMERIC) {
    String exactText = NumberToTextConverter.toText(cell.getNumericCellValue());
    BigDecimal value = new BigDecimal(exactText);
    // æ­¤æ—¶ value æ˜¯ Excel ä¸­å­˜å‚¨çš„精确值（15位有效数字）
}
🗄️ ç¬¬äºŒæ­¥ï¼šåœ¨æ•°æ®åº“中如何存储
数据库字段切忌使用 FLOAT æˆ– DOUBLE，因为它们同样存在二进制浮点误差，会导致与Excel结果的偏差。

推荐方案：使用 DECIMAL ç±»åž‹

DECIMAL（或 NUMERIC）是定点精确类型，它按整数位和小数位存储，能精确表示十进制小数。

数据库    æŽ¨èç±»åž‹    è¯´æ˜Ž
MySQL    DECIMAL(p, s)    p ä¸ºæ€»ç²¾åº¦ï¼Œs ä¸ºå°æ•°ä½ã€‚Excel æœ‰æ•ˆä½15，建议 p è‡³å°‘为 15，再根据小数位需求设定。例如 DECIMAL(18, 6)。
PostgreSQL    NUMERIC(p, s)    åŒä¸Šï¼Œæ ‡å‡†SQL类型。
SQL Server    DECIMAL(p, s)    åŒä¸Šã€‚
Oracle    NUMBER(p, s)    NUMBER ç±»åž‹å¯å­˜å‚¨å®šç‚¹æ•°ï¼Œæ•ˆæžœç­‰åŒã€‚
JDBC æ˜ å°„：使用 JDBC è¯»å†™æ—¶ï¼ŒDECIMAL å­—段会直接映射为 Java çš„ BigDecimal，保证了精度在传递过程中不丢失。

🧮 ç¬¬ä¸‰æ­¥ï¼šJava中的计算与舍入规则
即使存储精确，计算逻辑也必须模拟 Excel çš„行为。

1. å§‹ç»ˆä½¿ç”¨ BigDecimal è¿›è¡Œè®¡ç®—

BigDecimal çš„加减乘除（add, subtract, multiply, divide）都是精确计算，不会引入二进制误差。切勿将 BigDecimal è½¬å›ž double åŽå†è®¡ç®—。

2. æ¨¡æ‹Ÿ Excel çš„15位有效数字限制

Excel åœ¨æ¯æ¬¡å°†ä¸­é—´ç»“果写入单元格时，都会将结果舍入到15位有效数字。在 Java ä¸­ï¼Œéœ€è¦æ¨¡æ‹Ÿè¿™ä¸€è¡Œä¸ºã€‚

java
import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;

// åˆ›å»ºä¸€ä¸ªç²¾åº¦ä¸º15位有效数字，舍入模式为“四舍五入”的上下文
MathContext EXCEL_MC = new MathContext(15, RoundingMode.HALF_UP);

public BigDecimal excelRound(BigDecimal value) {
    // åº”用Excel的舍入规则
    return value.round(EXCEL_MC);
}

// ç¤ºä¾‹ï¼šåœ¨æ¯ä¸€æ­¥å…³é”®è®¡ç®—后调用
BigDecimal intermediate = a.add(b);
intermediate = excelRound(intermediate); // æ¨¡æ‹Ÿå†™å…¥å•å…ƒæ ¼
BigDecimal result = intermediate.multiply(c);
result = excelRound(result);
注意：Excel çš„舍入模式近似于“四舍五入”，但存在微妙的“银行家舍入”行为。RoundingMode.HALF_UP æ˜¯æœ€æŽ¥è¿‘的近似，但在极少数边缘情况下仍有差异。对于财务系统，建议在最终结果上按业务规则（如 RoundingMode.HALF_UP）显式保留固定小数位。

3. æ¯”较运算需特殊处理

Excel åœ¨æ¯”较数字时有额外的容差逻辑。例如，(0.06-0.01)=0.05 åœ¨ Excel ä¸­ä¸º TRUE，但在 Java çš„ double æ¯”较中为 false。Apache POI æä¾›äº† NumberComparer.compare(double a, double b) æ¥æ¨¡æ‹Ÿè¿™ç§æ¯”较行为。对于 BigDecimal，建议先按15位有效数字舍入后再用 compareTo() æ¯”较。

💎 æ€»ç»“
要在 Java ç”Ÿæ€ä¸­å¤çŽ° Excel çš„计算结果，关键在于：

入口精确：用 NumberToTextConverter + BigDecimal è¯»å–，避免 double æ±¡æŸ“。

存储精确：数据库使用 DECIMAL ç±»åž‹ï¼ŒJava å­—段使用 BigDecimal。

计算精确：全程使用 BigDecimal è¿ç®—。

舍入对齐：在每次可能产生中间结果的地方，用 MathContext(15, RoundingMode.HALF_UP) æ¨¡æ‹Ÿ Excel çš„15位有效数字截断。

比较容差：使用模拟 Excel è¡Œä¸ºçš„比较逻辑，而非直接比较。

这样就能最大程度地保证 Java ä¸Ž Excel çš„计算结果一致。

 docs/database.md

@@ -487,3 +487,66 @@
| /api/report/export/investFiveYearLogistics | "十五五"物流项目进展 | å›ºå®šåå•è¿‡æ»¤ï¼Œå¸‚州小节+项目行 |
| /api/report/export/investBillion | äº¿å…ƒæŠ•èµ„项目 | æŠ•èµ„总表 + è§„上项目表两sheet，亿元名单过滤 |
| /api/report/export/investCounty | ç»æµŽå¼ºåŽ¿æŠ•èµ„统计 | ç»æµŽå¼ºåŽ¿åå•è¿‡æ»¤ |


## ä¹ã€ä¸“项统计-重要节假日模块

> æ•°æ®æ¥æºä¸Žæ¨¡æ¿ï¼š`docs/专项统计/重要节假日/2026年十一数据.xlsx`；快报模板：`docs/专项统计/重要节假日/湖北省国庆假期综合运输客流快报模板.docx`。首次启动会从工作簿初始化 2024/2025 å¹´åä¸€å®¢æµã€è½¦æµæ•°æ®ï¼Œå¹¶åˆå§‹åŒ– 2024-2026 å¹´å®¢è¿ç³»æ•°ã€‚

### holiday_calendar èŠ‚假日日期配置
| å­—段 | ç±»åž‹ | è¯´æ˜Ž |
|------|------|------|
| id | bigint | PK |
| year | int | å¹´ä»½ |
| holiday_type | varchar(32) | æ˜¥èŠ‚ SPRING_FESTIVAL / äº”一 LABOR_DAY / åä¸€ NATIONAL_DAY |
| holiday_date | date | èŠ‚假日具体日期 |
| day_index | int | ç¬¬å‡ æ—¥ï¼Œä»Ž 1 å¼€å§‹ |
| created_at / updated_at | datetime | åˆ›å»º/更新时间 |

唯一键：`(year, holiday_type, day_index)`、`(year, holiday_type, holiday_date)`。仅 admin å¯é€šè¿‡ç³»ç»Ÿé…ç½®èœå•ç»´æŠ¤ã€‚

### holiday_passenger_flow èŠ‚假日综合运输营业性客流
| å­—段 | ç±»åž‹ | è¯´æ˜Ž |
|------|------|------|
| id | bigint | PK |
| year | int | å¹´ä»½ |
| flow_date | date | æ—¥æœŸ |
| transport_mode | varchar(32) | é“è·¯ RAIL / æ°‘航 CIVIL_AVIATION / é“è·¯ ROAD / æ°´è·¯ WATER |
| passenger_count | decimal(30,15) | å‘送旅客数（万人次） |
| created_at / updated_at | datetime | åˆ›å»º/更新时间 |

唯一键：`(year, flow_date, transport_mode)`。

### holiday_vehicle_flow èŠ‚假日综合运输非营业性车流
| å­—段 | ç±»åž‹ | è¯´æ˜Ž |
|------|------|------|
| id | bigint | PK |
| year | int | å¹´ä»½ |
| flow_date | date | æ—¥æœŸ |
| road_category | varchar(32) | é«˜é€Ÿå…¬è·¯ EXPRESSWAY / æ™®é€šå›½çœé“ NATIONAL_PROVINCIAL |
| vehicle_type | varchar(32) | å°å®¢è½¦ SMALL_PASSENGER / ä¸­å°å®¢è½¦ MEDIUM_SMALL_PASSENGER |
  | vehicle_count | decimal(30,15) | è½¦æµé‡ï¼ˆä¸‡è¾†æ¬¡ï¼‰ |
  | comparison_base | decimal(30,15) | æ™®é€šå›½çœé“环比基期（万辆次，仅当年使用） |
  | created_at / updated_at | datetime | åˆ›å»º/更新时间 |

唯一键：`(year, flow_date, road_category, vehicle_type)`。

### holiday_passenger_coefficient å®¢è¿ç³»æ•°é…ç½®
| å­—段 | ç±»åž‹ | è¯´æ˜Ž |
|------|------|------|
| id | bigint | PK |
| year | int | å¹´ä»½ |
| date_category | varchar(32) | èŠ‚假日 HOLIDAY / éžèŠ‚假日 NON_HOLIDAY |
| coefficient | decimal(30,15) | å®¢è¿ç³»æ•° |
| created_at / updated_at | datetime | åˆ›å»º/更新时间 |

唯一键：`(year, date_category)`。仅 admin å¯é€šè¿‡ç³»ç»Ÿé…ç½®èœå•ç»´æŠ¤ã€‚

### è®¡ç®—与导入导出口径
  - éžè¥ä¸šæ€§äººå‘˜æµåŠ¨é‡ =（高速车流 + æ™®é€šå›½çœé“车流）נ当年节假日客运系数。
  - 2026 å¹´æ™®é€šå›½çœé“如填写环比基期，则只影响普通国省道车流量自身环比：填写时按“当日 / çŽ¯æ¯”基期 - 1”，未填写时按“当日 / å‰ä¸€æ—¥ - 1”；折算人员流动量、总人员流动量等继续按 Excel åŽŸå…¬å¼è®¡ç®—。2024、2025 åŽ†å²æ•°æ®ä¸ä½¿ç”¨è¯¥å­—段。
  - å…¬è·¯äººå‘˜æµåŠ¨é‡ = é“路营业性客运量 + éžè¥ä¸šæ€§äººå‘˜æµåŠ¨é‡ã€‚
- æ€»äººå‘˜æµåŠ¨é‡ = å…¬è·¯ + é“è·¯ + æ°‘航 + æ°´è·¯ã€‚
- å¯¼å…¥æŒ‰â€œå¹´ä»½ + èŠ‚假日分类”读取 `holiday_calendar` çš„日期，将工作簿“第N日”行覆盖写入当年客流/车流；日常只读取所选年份的当年列，历史年份仅首次初始化。
- å¯¼å…¥å‰æ£€æŸ¥æ¯”本次最新导入日更早的历史日期是否发生变化；如有变化先不写库，返回差异清单，用户确认后才允许覆盖。
- å¯¼å‡ºä»¥æºå·¥ä½œç°¿ä¸ºåº•ç¨¿ï¼Œå›žå¡«åº“内数据与客运系数；快报按日期生成 Word å¹¶æ›¿æ¢æ¨¡æ¿ä¸­çš„当日、累计、环比和同比内容。

 docs/init.sql

@@ -619,3 +619,69 @@
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
  KEY idx_type_period (report_type, report_period)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='报表期审核通过标记';


-- ============================================
-- åä¸€ã€ä¸“项统计-重要节假日
-- ============================================

-- èŠ‚假日日期配置
DROP TABLE IF EXISTS holiday_calendar;
CREATE TABLE holiday_calendar (
  id BIGINT NOT NULL AUTO_INCREMENT,
  year INT NOT NULL COMMENT '年份',
  holiday_type VARCHAR(32) NOT NULL COMMENT '节假日分类：SPRING_FESTIVAL/LABOR_DAY/NATIONAL_DAY',
  holiday_date DATE NOT NULL COMMENT '节假日具体日期',
  day_index INT NOT NULL COMMENT '第几日，从 1 å¼€å§‹',
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (id),
  UNIQUE KEY uk_holiday_calendar_seq (year, holiday_type, day_index),
  UNIQUE KEY uk_holiday_calendar_date (year, holiday_type, holiday_date),
  KEY idx_holiday_calendar_date (holiday_date)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='重要节假日日期配置';

-- èŠ‚假日综合运输营业性客流
DROP TABLE IF EXISTS holiday_passenger_flow;
CREATE TABLE holiday_passenger_flow (
  id BIGINT NOT NULL AUTO_INCREMENT,
  year INT NOT NULL COMMENT '年份',
  flow_date DATE NOT NULL COMMENT '日期',
  transport_mode VARCHAR(32) NOT NULL COMMENT '运输方式：RAIL/CIVIL_AVIATION/ROAD/WATER',
  passenger_count DECIMAL(30,15) NOT NULL COMMENT '发送旅客数（万人次）',
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (id),
  UNIQUE KEY uk_holiday_passenger (year, flow_date, transport_mode),
  KEY idx_holiday_passenger_date (flow_date)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='节假日综合运输营业性客流情况';

-- èŠ‚假日综合运输非营业性车流
DROP TABLE IF EXISTS holiday_vehicle_flow;
CREATE TABLE holiday_vehicle_flow (
  id BIGINT NOT NULL AUTO_INCREMENT,
  year INT NOT NULL COMMENT '年份',
  flow_date DATE NOT NULL COMMENT '日期',
  road_category VARCHAR(32) NOT NULL COMMENT '道路分类：EXPRESSWAY/NATIONAL_PROVINCIAL',
  vehicle_type VARCHAR(32) NOT NULL COMMENT '车型分类：SMALL_PASSENGER/MEDIUM_SMALL_PASSENGER',
  vehicle_count DECIMAL(30,15) NOT NULL COMMENT '车流量（万辆次）',
  comparison_base DECIMAL(30,15) NULL COMMENT '普通国省道环比基期（万辆次，仅当年使用）',
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (id),
  UNIQUE KEY uk_holiday_vehicle (year, flow_date, road_category, vehicle_type),
  KEY idx_holiday_vehicle_date (flow_date)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='节假日综合运输非营业性车流情况';

-- å®¢è¿ç³»æ•°é…ç½®
DROP TABLE IF EXISTS holiday_passenger_coefficient;
CREATE TABLE holiday_passenger_coefficient (
  id BIGINT NOT NULL AUTO_INCREMENT,
  year INT NOT NULL COMMENT '年份',
  date_category VARCHAR(32) NOT NULL COMMENT '日期分类：HOLIDAY/NON_HOLIDAY',
  coefficient DECIMAL(30,15) NOT NULL COMMENT '客运系数',
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (id),
  UNIQUE KEY uk_holiday_coefficient (year, date_category)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='客运系数配置';

 docs/sql_holiday.sql

New file
@@ -0,0 +1,53 @@
-- Holiday statistics module. Run against the traffic_audit database.
CREATE TABLE IF NOT EXISTS holiday_calendar (
  id BIGINT NOT NULL AUTO_INCREMENT,
  year INT NOT NULL,
  holiday_type VARCHAR(32) NOT NULL,
  holiday_date DATE NOT NULL,
  day_index INT NOT NULL,
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (id),
  UNIQUE KEY uk_holiday_calendar_seq (year, holiday_type, day_index),
  UNIQUE KEY uk_holiday_calendar_date (year, holiday_type, holiday_date),
  KEY idx_holiday_calendar_date (holiday_date)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE IF NOT EXISTS holiday_passenger_flow (
  id BIGINT NOT NULL AUTO_INCREMENT,
  year INT NOT NULL,
  flow_date DATE NOT NULL,
  transport_mode VARCHAR(32) NOT NULL,
  passenger_count DECIMAL(30,15) NOT NULL,
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (id),
  UNIQUE KEY uk_holiday_passenger (year, flow_date, transport_mode),
  KEY idx_holiday_passenger_date (flow_date)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE IF NOT EXISTS holiday_vehicle_flow (
  id BIGINT NOT NULL AUTO_INCREMENT,
  year INT NOT NULL,
  flow_date DATE NOT NULL,
  road_category VARCHAR(32) NOT NULL,
  vehicle_type VARCHAR(32) NOT NULL,
  vehicle_count DECIMAL(30,15) NOT NULL,
  comparison_base DECIMAL(30,15) NULL COMMENT '普通国省道环比基期（万辆次，仅当年使用）',
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (id),
  UNIQUE KEY uk_holiday_vehicle (year, flow_date, road_category, vehicle_type),
  KEY idx_holiday_vehicle_date (flow_date)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

CREATE TABLE IF NOT EXISTS holiday_passenger_coefficient (
  id BIGINT NOT NULL AUTO_INCREMENT,
  year INT NOT NULL,
  date_category VARCHAR(32) NOT NULL,
  coefficient DECIMAL(30,15) NOT NULL,
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (id),
  UNIQUE KEY uk_holiday_coefficient (year, date_category)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

 docs/sql_holiday_comparison_base_migration.sql

New file
@@ -0,0 +1,6 @@
-- Add the optional ordinary national/provincial road comparison base.
-- The field is used only for the 2026 holiday data.
ALTER TABLE holiday_vehicle_flow
  ADD COLUMN comparison_base DECIMAL(30,15) NULL
  COMMENT '普通国省道环比基期（万辆次，仅当年使用）'
  AFTER vehicle_count;

 docs/sql_holiday_decimal_migration.sql

New file
@@ -0,0 +1,16 @@
-- Convert holiday statistics numeric columns from binary floating point to exact decimal storage.
-- Run once against the traffic_audit database.
ALTER TABLE holiday_passenger_flow
  MODIFY COLUMN passenger_count DECIMAL(30,15) NOT NULL COMMENT '发送旅客数（万人次）';

ALTER TABLE holiday_vehicle_flow
  MODIFY COLUMN vehicle_count DECIMAL(30,15) NOT NULL COMMENT '车流量（万辆次）';

ALTER TABLE holiday_passenger_coefficient
  MODIFY COLUMN coefficient DECIMAL(30,15) NOT NULL COMMENT '客运系数';

-- The seeded coefficient was averaged from repeated 2.4 cells through a Java double.
-- Normalize the migrated value to the exact Excel decimal.
UPDATE holiday_passenger_coefficient
SET coefficient = 2.4
WHERE year IN (2024, 2025, 2026);

 docs/רÏîͳ¼Æ/ÖØÒª½Ú¼ÙÈÕ/2026ÄêʮһÊý¾Ý.xlsx

Binary files differ

 docs/רÏîͳ¼Æ/ÖØÒª½Ú¼ÙÈÕ/±¸·Ý/2026ÄêʮһÊý¾Ý.xlsx

Binary files differ

 docs/רÏîͳ¼Æ/ÖØÒª½Ú¼ÙÈÕ/±¸·Ý/ºþ±±Ê¡¹úÇì¼ÙÆÚ×ÛºÏÔËÊä¿ÍÁ÷¿ì±¨Ä£°å.docx

Binary files differ

 docs/רÏîͳ¼Æ/ÖØÒª½Ú¼ÙÈÕ/ºþ±±Ê¡¹úÇì¼ÙÆÚ×ÛºÏÔËÊä¿ÍÁ÷¿ì±¨Ä£°å.docx

Binary files differ

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_2026-07ĸ°æ²¹ÆëÓëµ¼³ö¼þ´ò²»¿ªÐÞ¸´_2026-09-16.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_2026-09-02_µ¼ÈëÓ뱨±íÉú³É»Ø¹é.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_H2031Ä£°åÐÂÔöÁÐÊÊÅä_2026-09-16.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_M1-³ÇÊпÍÔË-¹«½»³ö×â¹ìµÀÂÖ¶É_2026-09-08.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_M1-³ÇÊпÍÔË-³ÇÊлã×ÜÕûÁ´»Ø¹é_2026-09-08.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_M1-°àÏß°ü³µMidCalc_2026-09-08.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_M1-ÍøÔ¼³µ²ð·ÖWycSplitCalc_2026-09-08.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_M1-»õÔËÈ¡ÊýÁ´Â·Óë7Ô»عé_2026-09-08.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_RULE001·ÖÏîÔËÕþÓëãÐÖµÁª¶¯¼°Áпí»Ø¹é_2026-09-09.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_Ò»¼üÆôÍ£½Å±¾Óë×ÀÃæÈë¿Ú_2026-09-19.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_Öпھ¶ËÄά¿Ú¾¶Í³Ò»_2026-09-18.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_Öпھ¶ÅÅÃûͬ±È»ùÊý·½°¸A_2026-09-21.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_Öпھ¶ÅÅÃûÖÜתÁ¿¿Ú¾¶Í³Ò»_2026-09-19.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_Öпھ¶ÅÅÃû×ó¿éɾ³ýÓë7Ô»عéÊÕ¿Ú¼°8ÔÂÀ©ÁÐ_2026-09-08.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_È«¾«¶È´æ´¢ÓëÁ½Î»Ð¡ÊýÏÔʾ_2026-09-20.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_¹«Â·Âÿͱ¨±í²¢Èë¸öÌå¿ÍÔË_2026-09-03.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_ͬÃûÆóÒµ1-8ÔÂÀۼƻõÔËÁ¿ÓëÖÜתÁ¿SQL_2026-09-19.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_³ÇÊпÍÔËÐÂÔöÍøÔ¼³µ²ð·Ö±íÓë»ã×ܹ¤×÷²¾¼°Á½Î»Ð¡ÊýÏÔʾ_2026-09-03.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_³ÇÊпÍÔËÔ¶ÈÓëÀÛ¼Æͬ±È_2026-09-20.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_³ÇÊпÍÔËÍøÔ¼³µµ¼ÈëÏÂÀ­_2026-09-04.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_ÉóºËƽ¾ù¶Öλ¿Ú¾¶Óë²ð·ÖÄ¿±êÔµ¼Èë¼°È«ÆÁ·­Ò³_2026-09-04.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_ÉóºË½çÃæ½»»¥ÓëÎÊÌâ»°Êõµ¼³ö_2026-09-09.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_ÉóºË½á¹ûÄ£°åչʾÓëµ¼³ö¼°±¨±íÒ³Õû¸Ä_2026-09-09.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_ÉóºË½á¹ûҳѡÔÂתȦÐÞ¸´_2026-09-09.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_µ¼ÈëУÑéÔöÇ¿_2026-09-02.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_µ¼ÈëÇå¿Õ°´ÀàÐÍÓë°´Å¥·ÀÎó´¥_2026-09-10.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_µ¼³ö»º´æ¸ÄÓÃÊý¾ÝÖ¸ÎÆ_2026-09-22.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_¾ÖÓòÍøIP·ÃÎʵǼCORSÐÞ¸´_2026-09-16.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_ÊÐÖÝͳһÌģ°åÓëÏØÊÐÇø½âÎö_2026-09-20.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_Ͷ×ÊÉóºËI004»ù׼ȱʧ±£»¤_2026-09-02.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_Ͷ×ÊÊÐÖÝÔ±¨¶àsheetʶ±ðÓëÐòºÅ¿Õ¸ñ_2026-09-02.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_Ͷ×ÊÃ÷ϸ±íÓëµ¼ÈëÈ¡Áж¨Î»ÐÞ¸´_2026-09-19.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_Ͷ×ÊÃ÷ϸ±íÈ¡ÊýÐÞ¸´_2026-09-22.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_Ͷ×ÊÃ÷ϸ±í¾ÍÐ÷ÓëÔ¤ÀÀÀàÐͲ¹Æë_2026-09-20.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_Ͷ×ÊÔ±¨Æ¥ÅäÓëУÑéÒýÇæ_2026-09-17.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_Ͷ×ÊÔ±¨È¡ÁдíλÐÞ¸´Ó뵯´°Ìáʾ_2026-09-17.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_Ͷ×ÊÔ±¨¸ñʽ̽²âÓë×Ö¶ÎÓ³Éä±í_2026-09-17.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_Ͷ×ÊÔ±¨Ô´Îļþ½âÎöÒýÇæ_2026-09-17.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_Ͷ×ÊϵͳÐÂÄ£°å°´±íÍ·½âÎöÓëÉóºË»ù׼ȱʧ±£»¤_2026-09-21.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_Ͷ×ÊÔ¤°²ÅÅ»ã×ܲ¹¼ÆÓëµ¼È뵯´°_2026-09-20.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_³ÖÐøÔÚ¹æÆóÒµ545¼Ò·ÖÊÐÖÝÀÛ¼ÆÔ˾àͬ±È_2026-09-19.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_½Ó¿Ú¼øȨÓëAIÊý¾ÝÍÑÃô¼Ó¹Ì_2026-09-14.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_Êý¾Ýµ¼ÈëÇå¿Õ°´Å¥°´±¨±íÆÚÇå¿â_2026-09-10.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_Êý¾Ýµ¼ÈëÒ³¿Õ°×ÐÞ¸´_2026-09-11.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_Êý¾Ý²é¿´¶³½áÁÐÓëÊý¾ÝÀàÐÍÏÂÀ­¿ò_2026-09-22.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_Êý¾Ý²é¿´¿Ú¾¶É¸Ñ¡Óë±íÍ·µ¥Î»_2026-09-22.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_Êý¾Ý²é¿´Õ¹Ê¾ÓÅ»¯ÓëÍøÔ¼³µ°´ÊÐÖÝÊúÅÅ_2026-09-22.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_Êý¾Ý²é¿´Í¶×ÊÄܺÄÓ뱨±íÆÚÅÅÐò_2026-09-17.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_Êý¾Ý²é¿´°´ÊÐÖÝ»ã×ÜÓëµ¼³ö_2026-09-22.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_Êý¾Ý²é¿´²¹ÆëÍøÔ¼³µÓë¸öÌå¿ÍÔËÀàÐÍ_2026-09-22.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_Õû¸Ä8Ïî»Ø¹éÑéÖ¤_2026-09-08.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_»ã×Ü´ó±í1-6ÔÂÉú³ÉÓë1-7ÔÂÀ©ÁÐÑéÖ¤_2026-09-04.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_»ã×Ü´ó±í8ÔÂÊý¾Ý»ØÌîÓë°æʽ¶ÔÆë_2026-09-11.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_»ã×Ü´ó±íËÄÒ³Êý¾ÝÇý¶¯_2026-09-13.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_»ã×Ü´ó±íµ¼³ö½á¹ûÂäÅÌ»º´æ¸´ÓÃ_2026-09-22.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_»ã×Ü´ó±íÒì²½µ¼³öÓ뻺´æ_2026-09-20.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_»ã×Ü´ó±íÊý¾ÝÇý¶¯»ØÌîM2̨Õ˲ã_2026-09-09.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_»ã×Ü´ó±íÈÕÆÚ¸ñʽÓë¹æÔòÁª¶¯¼°Êý¾Ý²é¿´¹ö¶¯¼ÓÔØ_2026-09-08.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_»ã×Ü´ó±í°æʽͳһ_2026-09-08.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_»ã×Ü´ó±í»õÔ˹æÉϹæϲ¹ÊýÓë³ÉÆ·Ò³µ±Ô¿éÐÞÕý_2026-09-07.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_»ã×Ü´ó±íÈí¼þÊä³öÓëÊÖ¹¤¶¨¸å²îÒì_2026-09-21.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_»ã×Ü´ó±í½ø¶Èµ¯´°ÓÅ»¯_2026-09-22.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_»ã×Ü´ó±íÔ¤ÀÀɾ³ýÖпھ¶ºóÃ÷ϸ±í_2026-09-16.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_»ã×ܹ¤×÷²¾Ô¶ȿéÀ©Áл¹Ô­ÊÔµã_2026-09-04.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_»ã×ܹ¤×÷²¾¹Ç¼ÜÉú³É_2026-09-03.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_»ã×Ü±í¹«Ê½À©Ò³ÓëÖØËã_2026-09-18.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_»ã×ܱíÅÅÃûҳˢÐÂÓëͬ±È°Ù·ÖÊý_2026-09-11.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_»ã×ܱíÕûÊý²»ÏÔʾ0.00ÓëÁпí×ÔÊÊÓ¦_2026-09-04.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_DZ½­Í¶×ÊÎïÁ÷Ô±¨Öص¼_2026-09-23.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_Éú³ÉÄ£°åаæʽ_2026-09-02.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_µÇ¼ÑéÖ¤ÂëÈÝ´íÓ뱨±íÔ¤ÀÀÕû¸Ä_2026-09-16.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_ÍøÔ¼³µ¶©µ¥±¨¸æWordML¼æÈݵ¼Èë_2026-09-18.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_ÍøÔ¼³µ¶©µ¥±¨¸æµ¼Èë_2026-09-11.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_¹æÉϹæϲð·ÖÔ·Ýҳǩʶ±ð_2026-09-04.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_»õÔËÔ±¨³ÖÐøÔÚ¹æÆóÒµ·ÖÊÐÖÝÀÛ¼ÆÔ˾à_2026-09-18.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_»õÔËÁ¿ÖÜתÁ¿2023ÄêÊý¾Ý²¹Â¼_2026-09-16.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_»õÔËÁ¿ÖÜתÁ¿¶àÄê¶Èµ¼Èë_2026-09-16.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_»õÔËҳǩÀÛ¼ÆÁÐÐÞ¸´ÓëÔàÆÚÇåÀí_2026-09-16.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_ÔËÕþ³µÁ¾Óë¹ì¼£Àï³Ìµ¼Èë»Ø¹é_2026-09-02.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_²¿Êð°ü´ò°üÓë¶ÀÁ¢Æô¶¯_2026-09-13.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/¹¦ÄܲâÊÔ±¨¸æ_Ô¤ÀÀÖ¸±êÃû³ÆÏÔʾÓë»õÔËÁ¿ºÏ¼Æµ¥Î»ÐÞÕý_2026-09-04.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/µ¼ÈëÓëÉú³ÉÄ£¿éÌå¼ìÎÊÌâÇåµ¥_2026-09-02.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/Êý¾Ý±È¶Ô±¨¸æ_Ͷ×ÊÃ÷ϸ±íÈí¼þÉú³ÉÓëÈ˹¤°æ_2026-09-22.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/»ã×Ü´ó±íÓ붨¸å±È¶Ô_2026-09-16.md

File was deleted

 docs/¹¦ÄܲâÊÔ±¨¸æ/»ã×Ü´ó±íÒì²½µ¼³ö½ø¶Èµ¯´°_2026-09-20.png

Binary files differ

 docs/¹¦ÄܲâÊÔ±¨¸æ/»õÔËÀÛ¼ÆÁк˶ÔÓëµ¼ÈëÊý¾ÝÌå¼ì_2026-09-16.md

File was deleted

 docs/¹¤×÷ÈÕ½á/¹¤×÷ÈÕ½á_2026-09-02.md

File was deleted

 docs/¹¤×÷ÈÕ½á/¹¤×÷ÈÕ½á_2026-09-03.md

File was deleted

 docs/¹¤×÷ÈÕ½á/¹¤×÷ÈÕ½á_2026-09-04.md

File was deleted

 docs/¹¤×÷ÈÕ½á/¹¤×÷ÈÕ½á_2026-09-05.md

File was deleted

 docs/¹¤×÷ÈÕ½á/¹¤×÷ÈÕ½á_2026-09-07.md

File was deleted

 docs/¹¤×÷ÈÕ½á/¹¤×÷ÈÕ½á_2026-09-08.md

File was deleted

 docs/¹¤×÷ÈÕ½á/¹¤×÷ÈÕ½á_2026-09-09.md

File was deleted

 docs/¹¤×÷ÈÕ½á/¹¤×÷ÈÕ½á_2026-09-10.md

File was deleted

 docs/¹¤×÷ÈÕ½á/¹¤×÷ÈÕ½á_2026-09-11.md

File was deleted

 docs/¹¤×÷ÈÕ½á/¹¤×÷ÈÕ½á_2026-09-13.md

File was deleted

 docs/¹¤×÷ÈÕ½á/¹¤×÷ÈÕ½á_2026-09-14.md

File was deleted

 docs/¹¤×÷ÈÕ½á/¹¤×÷ÈÕ½á_2026-09-15.md

File was deleted

 docs/¹¤×÷ÈÕ½á/¹¤×÷ÈÕ½á_2026-09-16.md

File was deleted

 docs/¹¤×÷ÈÕ½á/¹¤×÷ÈÕ½á_2026-09-17.md

File was deleted

 docs/¹¤×÷ÈÕ½á/¹¤×÷ÈÕ½á_2026-09-18.md

File was deleted

 docs/¹¤×÷ÈÕ½á/¹¤×÷ÈÕ½á_2026-09-19.md

File was deleted

 docs/¹¤×÷ÈÕ½á/¹¤×÷ÈÕ½á_2026-09-20.md

File was deleted

 docs/¹¤×÷ÈÕ½á/¹¤×÷ÈÕ½á_2026-09-21.md

File was deleted

 docs/¹¤×÷ÈÕ½á/¹¤×÷ÈÕ½á_2026-09-22.md

File was deleted

 docs/¹¤×÷ÈÕ½á/¹¤×÷ÈÕ½á_2026-09-23.md

File was deleted

 docs/¹¤¾ß/»ã×Ü´ó±í²îÒì±È¶Ô.py

New file
@@ -0,0 +1,240 @@
# -*- coding: utf-8 -*-
"""汇总大表差异比对：生成件 vs æ‰‹å·¥å®šç¨¿
用法: python æ±‡æ€»å¤§è¡¨å·®å¼‚比对.py <生成件.xlsx> <手工定稿.xlsx> <输出前缀>
说明: é€é¡µæŒ‰"行标签/列表头"做序列对齐（difflib），可正确处理多列/多行/重复表头；
      æ¯ä¸ªä¸ä¸€è‡´æ ¼å½’å…¥ ç»“构位移|取整尾差|文本型数字|草稿/辅助列|仅程序有|仅手工有|文本不同|错误值|实质数值差异。
"""
import datetime, io, os, re, sys
from difflib import SequenceMatcher
from openpyxl import load_workbook
from openpyxl.utils import get_column_letter

def col_label(ws, c, hdr_rows=6):
    for r in range(1, hdr_rows+1):
        v = ws.cell(row=r, column=c).value
        if isinstance(v, (int, float)) and not isinstance(v, bool) and 20000 < v < 60000:
            d = datetime.date(1899,12,30) + datetime.timedelta(days=int(v))
            return "%d-%02d" % (d.year, d.month)
        if isinstance(v, str) and v.strip() and not v.startswith("="):
            return v.strip()[:20]
    return "(无表头列)"

def row_label(ws):
    out = []; cur = ""; seen = {}
    for r in range(1, ws.max_row+1):
        a = ws.cell(row=r, column=1).value; b = ws.cell(row=r, column=2).value
        if isinstance(a, str) and a.strip(): cur = a.strip()
        if isinstance(b, str) and b.strip():
            lab = "%s|%s|%s" % (block_of(ws, r), norm_region(cur), norm_indicator(b))
        else:
            lab = "%s|%s|" % (block_of(ws, r), norm_region(cur))
        seen[lab] = seen.get(lab, 0) + 1
        out.append("%s#%d" % (lab, seen[lab]))
    return out

def norm(s):
    """标签归一化：去空白、去全角空格、统一引号、去掉‘市/省/州’后缀差异"""
    if not isinstance(s, str): return ""
    t = s.replace("\u3000", " ").replace("（", "(").replace("）", ")").strip()
    t = re.sub(r"[\s]+", "", t)
    return t

def norm_region(s):
    t = norm(s)
    for suf in ("市", "省", "自治州", "州"):
        if t.endswith(suf) and len(t) > len(suf): t = t[:-len(suf)]
    return t

def norm_indicator(s):
    t = norm(s).replace("(万吨公里)", "").replace("(万吨)", "").replace("(万人公里)", "").replace("(万人)", "")
    t = t.replace("其中规上", "规上").replace("其中规下", "规下")
    return t

def block_of(ws, r):
    """向上找最近一个"标题行"（B åˆ—为空且 A/文字较长）判断所属块：累计 / å½“月 / å…¶å®ƒ"""
    for rr in range(r, 0, -1):
        a = ws.cell(row=rr, column=1).value; b = ws.cell(row=rr, column=2).value
        txt = " ".join(str(x) for x in (a, b) if isinstance(x, str))
        if not isinstance(b, str) or not b.strip():
            if len(norm(txt)) >= 6:
                if "累计" in txt: return "累计块"
                if "各市州" in txt or "排名" in txt or "明细表" in txt: return "当月块"
    return "其它"

# å·²çŸ¥è®¾è®¡å·®å¼‚：不计入问题（按用户 2026-09-28 å£å¾„）
KNOWN_ROWS = {" è´§è¿": ("规上+规下货运量", "规下货运量")}
KNOWN_SHEETS_ANY_BLOCK = ()   # æŽ’名表的当月块由 block_of å¤„理

def is_known_extra_row(sheet, indicator, side):
    if sheet in KNOWN_ROWS and side == "程序":
        for pat in KNOWN_ROWS[sheet]:
            if norm_indicator(indicator) == norm_indicator(pat): return True
    return False

def num(v):
    return isinstance(v, (int, float)) and not isinstance(v, bool)

def text_num(v):
    if isinstance(v, str):
        s = v.strip().replace(",", "")
        try:
            return float(s)
        except Exception:
            return None
    return None

def match_labels(a, b):
    sm = SequenceMatcher(None, a, b, autojunk=False)
    pairs = {}
    for op, i1, i2, j1, j2 in sm.get_opcodes():
        if op == "equal":
            for k in range(i2-i1): pairs[i1+k] = j1+k
    return pairs

NOTE = """
> **已确认口径（2026-09-28，用户）——以下不计入问题**
> 1. ` è´§è¿` æ¯å¸‚å·ž 6 è¡Œ vs æ‰‹å·¥ 4 è¡Œï¼šç¨‹åºæ–°å¢žã€Œè§„上+规下货运量（万吨）」「规下货运量（万吨）」各 17 è¡Œï¼ˆå…± 34 è¡Œï¼‰ï¼Œå±žæ¯ç‰ˆè®¾è®¡ â†’ å½’入「已知设计(母版新增行)」。
>    å› è¡Œæ•°ä¸åŒï¼Œç¬¬ k ä¸ªå¸‚州在程序里比手工低 2×(k-1) è¡Œï¼ˆæ­¦æ±‰éƒ½ä»Žç¬¬ 11 è¡Œèµ·ï¼›é»„石 ç¨‹åº 17 / æ‰‹å·¥ 15；神农架 ç¨‹åº 107 / æ‰‹å·¥ 75）——**纯位置偏移，按"地区+指标"对齐后数值一致**。
> 2. ` è´§è¿!U5:U112`（无表头辅助列）是人工草稿 â†’ å½’入「已知设计(无表头草稿列)」。
> 3. å„排名表「当月块」是当初做母版时就加上的设计 â†’ å½’入「已知设计(排名表当月/累计块)」。
> 4. å¸‚州名短名/全名（武汉 vs æ­¦æ±‰å¸‚）不影响 â†’ å·²åšå½’一化。
> 5. å–整尾差、文本型数字只在汇总里计数，不进「实质数值差异」清单。
>
> **仍需处理/核对**
> - `班线包车` 3 æ ¼ï¼š`EO36`/`FN36`/`FO36`（荆门 å®¢è¿é‡ 2020 ç´¯è®¡/累计同比）——**程序生成时重算为 -2731.41 / -1.0008 / -1.0002**，母版与手工定稿均为 0.181777 / 2312.2199 / -0.586419；疑母版 2020 å¹´å—分母为 0，需核对公式与数据。
> - ` è´§è¿` 10 æ¡ 2022 å¹´å„市州「累计同比」：业务已确认**软件口径正确**（手工那列错）。
> - æ‰‹å·¥ä¾§å¾…改：304 æ ¼è‰ç¨¿åˆ—、286 æ ¼æ–‡æœ¬åž‹æ•°å­—、4 å¤„脏数据（`班线包车!IL4/IL5` æ–­é“¾ã€`IL50` åå¼•å·ã€` è´§è¿!EA93/EA111` çš„ `#DIV/0!`）。
> - æ¯ç‰ˆ/程序自身：11 ä¸ª `#REF!` + 356 ä¸ª `#DIV/0!`（历史遗留）、`城市客运` ç¬¬ 2 è¡Œç¬¬ 3 ä¸ªæœˆèµ·è¡¨å¤´ä¸ºæ—¥æœŸåºåˆ—号、缺 2026-09 æ¯ç‰ˆã€å¯¼å‡ºå‰åŸºæ•°ä½“检未做。

"""

def main(gen, dgf, prefix):
    ACTION = ("实质数值差异", "错误值(程序)", "错误值(手工)", "需处理(非数值文本)", "文本不同")
    IGNORE = ("已忽略(单边有值)", "已忽略(结构/设计)", "取整尾差(可忽略)", "文本型数字(可忽略)",
              "已知设计(母版新增行)", "已知设计(无表头草稿列)", "已知设计(排名表当月/累计块)", "其它")
    cats = list(ACTION) + list(IGNORE)
    REASON = {(" è´§è¿", "EA"): "2022年各市州累计同比：业务已确认软件口径正确（手工那列错）",
              ("班线包车", "EO"): "程序生成时重算（疑母版2020年块分母为0）：母版/手工为 0.1818，待核对",
              ("班线包车", "FN"): "同上：母版/手工为 2312.2199",
              ("班线包车", "FO"): "同上：母版/手工为 -0.5864"}
    def reason_of(x):
        ref = x[1]
        col = "".join(ch for ch in ref if ch.isalpha())
        return REASON.get((x[0], col), "")

    g = load_workbook(gen, data_only=True); d = load_workbook(dgf, data_only=True)
    rows_out = []
    per_sheet = []
    for sh in g.sheetnames:
        if sh not in d.sheetnames: continue
        wg, wd = g[sh], d[sh]
        rl_g, rl_d = row_label(wg), row_label(wd)
        cl_g = [col_label(wg, c) for c in range(1, wg.max_column+1)]
        cl_d = [col_label(wd, c) for c in range(1, wd.max_column+1)]
        colmap = match_labels(cl_g, cl_d); rowmap = match_labels(rl_g, rl_d)
        cnt = {}
        def bump(k):
            cnt[k] = cnt.get(k, 0) + 1
        # åˆ—/行的结构性缺口
        unmatched_cols_g = [c-1 for c in range(1, len(cl_g)+1) if c-1 not in colmap]
        unmatched_cols_d = [c-1 for c in range(1, len(cl_d)+1) if c-1 not in set(colmap.values())]
        unmatched_rows_g = [r-1 for r in range(1, len(rl_g)+1) if r-1 not in rowmap]
        unmatched_rows_d = [r-1 for r in range(1, len(rl_d)+1) if r-1 not in set(rowmap.values())]
        for c in unmatched_cols_g:
            if c < 2: continue
            if cl_g[c] == "(无表头列)":
                bump("已知设计(无表头草稿列)"); continue
            bump("已忽略(结构/设计)")
        for c in unmatched_cols_d:
            if c < 2: continue
            if cl_d[c] == "(无表头列)":
                bump("已知设计(无表头草稿列)"); continue
            bump("已忽略(结构/设计)")
        for r in unmatched_rows_g:
            if r < 4: continue
            rowb = "%s" % wg.cell(row=r+1, column=2).value
            if is_known_extra_row(sh, rowb, "程序"):
                bump("已知设计(母版新增行)"); continue
            bump("已忽略(结构/设计)")
        for r in unmatched_rows_d:
            if r < 4: continue
            if "当月块" in rl_d[r] or "累计块" in rl_d[r]:
                bump("已知设计(排名表当月/累计块)"); continue
            bump("已忽略(结构/设计)")
        for i, j in sorted(colmap.items()):
            if cl_g[i] == "(无表头列)" or cl_d[j] == "(无表头列)":
                bump("已知设计(无表头草稿列)"); continue
            for p, q in sorted(rowmap.items()):
                vg = wg.cell(row=p+1, column=i+1).value; vd = wd.cell(row=q+1, column=j+1).value
                if vg == vd: continue
                if vg is None and isinstance(vd, str) and vd.startswith("="): vd = None
                if vd is None and isinstance(vg, str) and vg.startswith("="): vg = None
                if (vg is None) and (vd is None): continue
                cat = None; note = ""
                tg, td = text_num(vg), text_num(vd)
                if num(vg) and num(vd):
                    diff = abs(vg - vd)
                    if diff <= 1e-6: continue
                    rel = diff / max(abs(vd), 1e-9)
                    if diff <= 0.01 or rel <= 1e-4: cat = "取整尾差(可忽略)"
                    else: cat = "实质数值差异"
                    note = "å·®=%.6g" % diff
                elif num(vg) and (vd is None):
                    cat = "已忽略(单边有值)"
                elif num(vd) and (vg is None):
                    cat = "已忽略(单边有值)"
                elif tg is not None and num(vd) and abs(tg - vd) <= 1e-9:
                    cat = "文本型数字(可忽略)"; note = "手工为文本'%s'" % vg
                elif td is not None and num(vg) and abs(td - vg) <= 1e-9:
                    cat = "文本型数字(可忽略)"; note = "程序为文本'%s'" % vd
                elif isinstance(vg, str) and isinstance(vd, str):
                    cat = "文本不同"; note = "程序'%s' / æ‰‹å·¥'%s'" % (vg[:18], vd[:18])
                elif isinstance(vg, str) and vg.startswith("#") :
                    cat = "错误值(程序)"; note = vg
                elif isinstance(vd, str) and vd.startswith("#"):
                    cat = "错误值(手工)"; note = vd
                elif (num(vg) and isinstance(vd, str)) or (num(vd) and isinstance(vg, str)):
                    cat = "需处理(非数值文本)"; note = "程序=%s æ‰‹å·¥=%s" % (str(vg)[:14], str(vd)[:14])
                else:
                    cat = "其它"; note = "程序=%s æ‰‹å·¥=%s" % (str(vg)[:14], str(vd)[:14])
                if cat:
                    bump(cat)
                    rows_out.append([sh, "%s%d" % (get_column_letter(i+1), p+1), rl_g[p][:38], cl_g[i][:18], cat,
                                     ("" if vg is None else str(vg)[:20]), ("" if vd is None else str(vd)[:20]), note,
                                     "%s%d" % (get_column_letter(j+1), q+1)])
        per_sheet.append((sh, cnt))
    # è¾“出 CSV
    csv = prefix + ".csv"
    with io.open(csv, "w", encoding="utf-8-sig", newline="") as f:
        f.write("页签,生成件单元格,行标签,列表头,类别,生成件值,手工值,备注,手工单元格\n")
        for x in rows_out:
            if x[4] not in ACTION: continue
            f.write(",".join('"%s"' % str(v).replace('"', "'") for v in x) + "\n")
    # è¾“出 MD
    md = prefix + ".md"
    with io.open(md, "w", encoding="utf-8", newline="\n") as f:
        f.write("# æ±‡æ€»å¤§è¡¨å·®å¼‚明细（生成件 vs æ‰‹å·¥å®šç¨¿ï¼‰\n\n")
        f.write("- ç”Ÿæˆä»¶ï¼š`%s`\n- æ‰‹å·¥å®šç¨¿ï¼š`%s`\n- æ¯”对时间：%s\n- æ˜Žç»†æ•°æ®ï¼š`%s`\n\n" % (gen, dgf, datetime.datetime.now().strftime("%Y-%m-%d %H:%M"), os.path.basename(csv)))
        f.write("## é€é¡µæ±‡æ€»\n\n| é¡µç­¾ | " + " | ".join(cats[:7]) + " |\n|---|" + "---|"*7 + "\n")
        for sh, cnt in per_sheet:
            f.write("| %s | %s |\n" % (sh, " | ".join(str(cnt.get(c, 0)) for c in cats[:7])))
        f.write("\n## éœ€å¤„理差异（全部，含原因）\n\n")
        subs = [x for x in rows_out if x[4] in ACTION and x[4] != "文本不同"]
        if not subs: f.write("（无）\n")
        for x in subs[:300]:
            f.write("- **%s** %s [%s] ç”Ÿæˆä»¶=%s æ‰‹å·¥=%s%s\n" % (x[0], x[1], x[2], x[5], x[6],
                    ("（原因：%s）" % reason_of(x)) if reason_of(x) else ""))
        f.write("\n## æ ‡é¢˜/表头措辞差异\n\n")
        tt = [x for x in rows_out if x[4] == "文本不同"]
        if not tt: f.write("（无）\n")
        for x in tt[:50]:
            f.write("- %s %s [%s] ç”Ÿæˆä»¶=%s æ‰‹å·¥=%s\n" % (x[0], x[1], x[2], x[5], x[6]))
        f.write("\n## å·²æŒ‰å£å¾„忽略（仅计数，明细见 CSV ä¹‹å¤–不列出）\n\n| é¡µç­¾ | " + " | ".join(IGNORE) + " |\n|---|" + "---|"*len(IGNORE) + "\n")
        for sh, cnt in per_sheet:
            f.write("| %s | %s |\n" % (sh, " | ".join(str(cnt.get(c, 0)) for c in IGNORE)))
    print("已输出:", md, "|", csv, "| æ˜Žç»†æ¡æ•°:", len(rows_out))
    for sh, cnt in per_sheet:
        if cnt: print("   %-12s %s" % (sh, dict(cnt)))

if __name__ == "__main__":
    main(sys.argv[1], sys.argv[2], sys.argv[3])

 docs/´ò°ü²¿Êð˵Ã÷.md

@@ -63,7 +63,10 @@
│  â”œâ”€ init.sql                                  å»ºåº“建表 + é¢„置账号（必须执行）
│  â”œâ”€ sql_city_bus.sql                          åŸŽå¸‚客运-公交月度表（必须执行）
│  â”œâ”€ sql_city_taxi.sql                         åŸŽå¸‚客运-出租月度表/授权表（必须执行）
│  â””─ sql_wyc.sql                               ç½‘约车全省总量/订单分市州表（必须执行）
│  â”œâ”€ sql_wyc.sql                               ç½‘约车全省总量/订单分市州表（必须执行）
│  â”œâ”€ sql_holiday.sql                           ä¸“项统计-重要节假日表（旧库补建时执行）
│  â”œâ”€ sql_holiday_decimal_migration.sql         èŠ‚假日数值列精度迁移（旧库升级）
│  â””─ sql_holiday_comparison_base_migration.sql èŠ‚假日环比基期字段迁移（旧库升级）
└─ README-部署说明.txt
```

@@ -77,14 +80,15 @@

```bash
cd db
mysql --default-character-set=utf8mb4 -u root -p            < init.sql          # å»ºåº“ + 24 å¼ åŸºç¡€è¡¨ + é¢„置账号
mysql --default-character-set=utf8mb4 -u root -p            < init.sql          # å»ºåº“ + 28 å¼ åŸºç¡€è¡¨ + é¢„置账号
mysql --default-character-set=utf8mb4 -u root -p -D traffic_audit < sql_city_bus.sql
mysql --default-character-set=utf8mb4 -u root -p -D traffic_audit < sql_city_taxi.sql
mysql --default-character-set=utf8mb4 -u root -p -D traffic_audit < sql_wyc.sql
```

> âš ï¸ **`init.sql` æ˜¯ç ´åæ€§çš„**：里面的基础表都带 `DROP TABLE IF EXISTS`。**已有数据的库上千万不要再跑 init.sql**，否则表数据会被清空重建。
> 4 ä¸ªè„šæœ¬å…±è¦†ç›– 29 å¼ è¡¨ï¼ˆinit.sql 24 å¼  + åŸŽå¸‚客运 3 å¼  + ç½‘约车 2 å¼ ï¼‰ã€‚
> æ—©æœŸç‰ˆæœ¬åº“若没有节假日 4 å¼ è¡¨ï¼Œæ‰§è¡Œ `sql_holiday.sql`；若已有节假日表但缺精度或环比基期字段，按需执行两个迁移脚本。
> 4 ä¸ªè„šæœ¬å…±è¦†ç›– 33 å¼ è¡¨ï¼ˆinit.sql 28 å¼ ï¼Œå…¶ä¸­å«èŠ‚假日 4 å¼  + åŸŽå¸‚客运 3 å¼  + ç½‘约车 2 å¼ ï¼‰ã€‚

#### è·¯çº¿ B：把现网/开发机的数据整套搬过去（推荐，不用跑脚本）

@@ -107,9 +111,9 @@

- `--databases` ä¼šæŠŠ `CREATE DATABASE` + `USE` ä¸€èµ·å†™è¿›å¤‡ä»½ï¼Œæ‰€ä»¥ç›®æ ‡æœºå™¨**不用先建库、也不用跑那 4 ä¸ªè„šæœ¬**。
- å¤‡ä»½é‡ŒåŒ…含 `sys_user`，账号密码与源机器完全一致（本机是 `admin / 123456`），不会被重置成 `admin/admin123`。
- âš ï¸ å¤‡ä»½é‡Œæ¯å¼ è¡¨éƒ½å¸¦ `DROP TABLE IF EXISTS`（共 29 å¼ ï¼‰ï¼š**目标库要是已有数据，会被直接覆盖**。请还原到空库，或先自己备份目标库。
- âš ï¸ å¤‡ä»½é‡Œæ¯å¼ è¡¨éƒ½å¸¦ `DROP TABLE IF EXISTS`（以实际备份为准，最新为 33 å¼ ï¼‰ï¼š**目标库要是已有数据，会被直接覆盖**。请还原到空库，或先自己备份目标库。
- æœ¬æ¬¡å·²ç”Ÿæˆå¹¶**验证过**备份：`traffic_audit_full_20260913.sql`（45.5 MB，8.0.29 å®¢æˆ·ç«¯å¯¼å‡ºï¼‰ã€‚
  éªŒè¯æ–¹å¼ï¼šæŠŠå¤‡ä»½åº“名改成临时库导入，逐表比对 `SHOW CREATE TABLE`（表结构）与 `COUNT(*)`（行数）——**29 å¼ è¡¨ç»“构与行数均 0 å·®å¼‚**，抽查 `wyc_order_monthly` 2026-08 æ•°æ®ä¸€è‡´ï¼ŒéªŒè¯åŽå·²åˆ é™¤ä¸´æ—¶åº“。
  éªŒè¯æ–¹å¼ï¼šæŠŠå¤‡ä»½åº“名改成临时库导入，逐表比对 `SHOW CREATE TABLE`（表结构）与 `COUNT(*)`（行数）——**29 å¼ è¡¨ç»“构与行数均 0 å·®å¼‚（新增节假日模块后为 33 å¼ ï¼‰**，抽查 `wyc_order_monthly` 2026-08 æ•°æ®ä¸€è‡´ï¼ŒéªŒè¯åŽå·²åˆ é™¤ä¸´æ—¶åº“。

#### è·¯çº¿ B2：用 Navicat çš„「备份 / è¿˜åŽŸå¤‡ä»½ã€ï¼ˆ.nb3，最贴近日常习惯）

@@ -204,7 +208,7 @@
| å¯¼å‡ºæŠ¥ã€Œæœªæ‰¾åˆ°æ±‡æ€»è¡¨æ¯ç‰ˆã€ŠYYYYå¹´M月…》」 | `docs/生成汇总大表` ç¼ºè¯¥æœˆæ¯ç‰ˆ |
| ç™»å½•æŽ¥å£ 500 | `jwt.secret` å¡«äº†éžæ³•å­—符（如中文）；改成 32 ä½åå…­è¿›åˆ¶ä¸² |
| é¡µé¢èƒ½å¼€ä½†æŽ¥å£ 404 | èµ° nginx æ–¹æ¡ˆæ—¶æ²¡é… `/api` åä»£ï¼›æ”¹ç”¨ jar å†…嵌访问 8090 |
| æ•°æ®åº“连接失败 | æ£€æŸ¥ `application.yml`；确认 4 ä¸ª SQL è„šæœ¬å·²æ‰§è¡Œ |
| æ•°æ®åº“连接失败 | æ£€æŸ¥ `application.yml`；确认 5 ä¸ª SQL è„šæœ¬å·²æ‰§è¡Œ |
| ç«¯å£å ç”¨ | æ”¹ `server.port`；前端开发端口 8080 |

## åã€å¼€å‘环境日常启动
@@ -219,3 +223,75 @@

- **2026-09-13**：新增一键打包脚本 `package-deploy.py`；jar æ”¹ä¸ºå†…嵌前端（部署机不再需要 nginx）；删除 Redis ç›¸å…³è¯´æ˜Žï¼ˆä»£ç æœªä½¿ç”¨ï¼‰ï¼›è¡¥ `sql_wyc.sql` ä¸Ž `summary.template-dir`；补 `jwt.secret` å–值规则；补部署后验证清单。
- 2026-08-27：首版（zip éƒ¨ç½²åŒ… + nginx æ–¹æ¡ˆï¼‰ã€‚

---

## å¯†é’¥ä¸Žé…ç½®ï¼ˆ2026-09-26 èµ·ï¼Œæ‰“包必读）

### åˆ†å±‚约定

| ä½ç½® | ç”¨é€” | æ˜¯å¦è¿› git | æ˜¯å¦è¿› jar |
| --- | --- | --- | --- |
| `traffic-audit-server/src/main/resources/application.yml` | è¿› jar çš„默认配置，**只有占位符**（`${TRAFFIC_DB_PASSWORD:}`、`${DEEPSEEK_API_KEY:}` ç­‰ï¼‰ | å¦ï¼ˆå·² gitignore，用 `application.yml.example` åšæ¨¡æ¿ï¼‰ | **是**（无真实值） |
| `traffic-audit-server/config/application.yml` | æœ¬æœºå¼€å‘真实值（库口令 / JWT / DeepSeek key） | å¦ï¼ˆå·² gitignore） | å¦ |
| jar åŒçº§çš„ `backend/application.yml` | éƒ¨ç½²æœºçœŸå®žå€¼ï¼ˆä¼˜å…ˆçº§é«˜äºŽ jar å†…置） | å¦ | å¦ï¼ˆåœ¨åŒ…外，现场填） |
| çŽ¯å¢ƒå˜é‡ `TRAFFIC_DB_PASSWORD` / `TRAFFIC_DB_USER` / `TRAFFIC_DB_URL` / `TRAFFIC_JWT_SECRET` / `DEEPSEEK_API_KEY` | è¦†ç›–以上任意一项 | å¦ | å¦ |

### æœ¬æœºå¼€å‘（值放环境变量，不落文件）

```powershell
setx TRAFFIC_DB_PASSWORD "本机 MySQL å£ä»¤"     # è®¾ä¸€æ¬¡å³å¯ï¼Œä¹‹åŽæ–°å¼€çš„终端自动带上
setx DEEPSEEK_API_KEY   "DeepSeek key"
# éœ€è¦æ—¶å†è¦†ç›–：setx TRAFFIC_DB_URL / TRAFFIC_DB_USER / TRAFFIC_JWT_SECRET

powershell -NoProfile -ExecutionPolicy Bypass -File start-dev.ps1   # ä¼šè‡ªåŠ¨ä»Žæ³¨å†Œè¡¨è¡¥é½å¹¶æ³¨å…¥åŽç«¯è¿›ç¨‹
```

- `traffic-audit-server/config/application.yml` åªç•™æ³¨é‡Šè¯´æ˜Žï¼ˆæ— æ˜Žæ–‡ï¼‰ï¼›åˆ æŽ‰å®ƒä¹Ÿä¸å½±å“ï¼ˆå€¼å…¨åœ¨çŽ¯å¢ƒå˜é‡é‡Œï¼‰ã€‚
- è‹¥ç”¨ IDE ç›´æŽ¥è·‘主类，请在**新开的**终端/IDE é‡Œå¯åŠ¨ï¼ˆè®©æ–°ç»ˆç«¯ç»§æ‰¿ç”¨æˆ·çŽ¯å¢ƒå˜é‡ï¼‰ï¼Œæˆ–手动 `setx` åŽé‡å¯ IDE。

### æ‰“包前自查（30 ç§’）

```powershell
# 1) ç¡®è®¤è¿› jar çš„配置没有真实密钥（应只看到 ${...}）
Select-String -Path traffic-audit-server\src\main\resources\application.yml -Pattern "password:|api-key:|secret:"
# 2) æ‰“完包后再验证一次 jar å†…部
python -c "import zipfile;print(zipfile.ZipFile('traffic-audit-server/target/traffic-audit-server-1.0.0-SNAPSHOT.jar').read('BOOT-INF/classes/application.yml').decode('utf-8'))" | Select-String "password:|api-key:"
```


### ä¸€é”®æ‰“包（推荐，2026-09-27 èµ·ï¼‰

```powershell
powershell -NoProfile -ExecutionPolicy Bypass -File pack-deploy.ps1
# å¯é€‰å‚数： -OutRoot "E:\试验"   -SkipFrontend
```

脚本做四件事：
1. `mvn clean package -DskipTests` æž„建后端 jar；
2. **解压 jar è‡ªæ£€**：检查 `BOOT-INF/classes/application.yml` æ˜¯å¦å…¨ä¸ºå ä½ç¬¦â€”—一旦发现 `sk-` æˆ–明文口令**直接中止打包**；
3. `npm run build` é‡å»ºå‰ç«¯ `dist`；
4. æŒ‰ `deploy-templates/` ç»„装完整部署包（backend / frontend / db / README-部署说明.txt），输出到 `<OutRoot>\traffic-audit-deploy-<yyyyMMdd>`。

模板件统一放在 **`deploy-templates/`**（已入库）：外部 `application.yml`、`start-backend.cmd/.sh`、`nginx.conf.example`、`db\{init.sql,sql_city_bus,sql_city_taxi,sql_wyc}.sql`、`README-部署说明.txt`。改模板即改打包产物。

### è½®æ¢å¯†é’¥åŽåŒæ­¥æœ¬æœº

```powershell
powershell -NoProfile -ExecutionPolicy Bypass -File set-secrets.ps1
```

交互式输入（回车跳过某一项），自动 `setx` åˆ°ç”¨æˆ·çŽ¯å¢ƒå˜é‡å¹¶æç¤ºé‡å¯åŽç«¯ï¼›å€¼ä¸ä¼šå†™å…¥ä»»ä½•æ–‡ä»¶ã€‚

### éƒ¨ç½²æœºä¸ŠåŠ /换 DeepSeek key

1. æ‰“包上传后，编辑 **jar åŒçº§**的 `backend/application.yml`：`deepseek.api-key: "你的新key"`（留空则页面 AI åˆ†æžä¸å¯ç”¨ï¼Œå…¶ä½™åŠŸèƒ½æ­£å¸¸ï¼‰ï¼›
2. é‡å¯åŽç«¯ï¼š`start-backend.cmd`（或 `java -jar traffic-audit-server-1.0.0-SNAPSHOT.jar`）；
3. é¡µé¢é‡Œç‚¹ä¸€æ¬¡ AI åˆ†æžç¡®è®¤å¯ç”¨ï¼›
4. **不要**去改 jar å†…部的配置（改了下次发包就丢），也不要把 key æäº¤è¿›ä»»ä½•ä»“库文件。

### è½®æ¢ï¼ˆä½œåºŸï¼‰å·²æ³„露的 key

1. ç™»å½• DeepSeek æŽ§åˆ¶å° â†’ API Keys â†’ æ–°å»ºä¸€ä¸ª key；
2. åˆ é™¤/禁用旧 key（旧 key ç«‹åˆ»å¤±æ•ˆï¼Œæ­¤å‰æ‰“包带出去的 jar é‡Œé‚£ä»½å³ä½œåºŸï¼‰ï¼›
3. æŒ‰ä¸Šé¢ç¬¬ 1~3 æ­¥æŠŠæ–° key å¡«åˆ°éƒ¨ç½²æœºçš„外部配置并重启验证。

 docs/Ä£¿é¹¦ÄÜÑé֤״̬¾ØÕó_2026-09-02.md

 docs/Éú³É»ã×Ü´ó±í/2026Äê8ÔµÀ·ÔËÊäÁ¿»ã×ܱí.xlsx

Binary files differ

 docs/ÎÊÌâ»ã×Ü/Êý¾Ý²é¿´»ã×ÜÓë»ã×Ü´ó±í¿Ú¾¶¶ÔÓ¦¹Øϵ_2026-09-23.md

New file
@@ -0,0 +1,40 @@
# æ•°æ®æŸ¥çœ‹ã€ŒæŒ‰å¸‚州汇总」与「汇总大表」口径对应关系与一致性核对（2026-09-23）

> æ ¸å¯¹æ—¥æœŸï¼š2026-09-23　提问：数据查看里的汇总功能与大表生成的数据是否一致
> æ ¸å¯¹æ–¹å¼ï¼šå¤§è¡¨å–自程序输出 `D:\桌面\生成数据\生成_道路运输量汇总表_2026-08 (3).xlsx`（含缓存直出，2026-09-22 14:10 ç”Ÿæˆï¼‰ï¼›æ•°æ®æŸ¥çœ‹å–自 `/api/data/summary?from=2026-01&to=2026-08`
> æ ¸å¯¹æ–¹å¼ï¼šå¤§è¡¨é€æœˆåˆ—加总 vs æ±‡æ€»æŽ¥å£é€å€¼æ¯”对（当时用的临时脚本与中间文件已随历史临时件清理；需要复现按本文第四节方法重跑）

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

**一致。** ä¸‰ä¸ªå¯ç›´æŽ¥å¯¹ä½çš„口径（城市公交、巡游出租、网约车）**逐位相同**：

| é¡¹ç›® | æ¯”对值个数 | è¶…出容差(>0.01) | æœ€å¤§ç»å¯¹å·® |
| --- | --- | --- | --- |
| åŸŽå¸‚公交（客运量/旅客周转量/城市内两项 Ã— å…¨çœ+17市州） | 72 | 0 | 0.000000 |
| å·¡æ¸¸å‡ºç§Ÿï¼ˆåŒä¸Š 4 æŒ‡æ ‡ï¼‰ | 72 | 0 | 0.000000 |
| ç½‘约车（拆分口径 4 æŒ‡æ ‡ï¼‰ | 72 | 0 | 0.000000 |

货运侧因为大表分「规上 / è§„下 / åˆè®¡ã€ä¸‰å—，需按块对应（见第二节），**对应后也完全一致**。

## äºŒã€å£å¾„对应关系

| æ•°æ®æŸ¥çœ‹ç±»åž‹ | å¯¹åº”大表位置 | å£å¾„ | æ ¸å¯¹æ ·ä¾‹ï¼ˆ2026 å¹´ 1-8 æœˆï¼‰ |
| --- | --- | --- | --- |
| `cityBus` åŸŽå¸‚公共交通 | ã€Œå…¬äº¤ã€é¡µå„市州 4 æŒ‡æ ‡ | å°è´¦å€¼é€æœˆç›¸åŠ  | å…¨çœå®¢è¿é‡ 110776.34 ä¸‡äººæ¬¡ã€æ—…客周转量 738254.64 ä¸‡äººå…¬é‡Œ â€”— é€ä½ä¸€è‡´ |
| `cityTaxi` å·¡æ¸¸å‡ºç§Ÿ | ã€Œå‡ºç§Ÿã€é¡µå„市州 4 æŒ‡æ ‡ | åŒä¸Š | å…¨çœå®¢è¿é‡ 48069.02 ä¸‡äººæ¬¡ã€æ—…客周转量 280664.05 ä¸‡äººå…¬é‡Œ â€”— é€ä½ä¸€è‡´ |
| `wycOrder` ç½‘约车 | ã€Œç½‘约车」页各市州 4 æŒ‡æ ‡ | æ‹†åˆ†å£å¾„（订单占比 Ã— å…¨çœ pin，城市内按巡游出租占比代理），与 `WycSplitCalc` åŒæº | å…¨çœå®¢è¿é‡ 33864.94 ä¸‡äººæ¬¡ç­‰ 4 é¡¹ â€”— é€ä½ä¸€è‡´ |
| `h2032` è´§è¿ä¼ä¸š | ã€Œè´§è¿é‡æŽ’名 / è´§è¿å‘¨è½¬é‡æŽ’名」的**规上**列 | è§„上企业月报（h2032） | å…¨çœè§„上货运量 31399.8248 ä¸‡å¨ = 313,998,248 å¨ï¼ˆä¸€è‡´ï¼‰ï¼›æ­¦æ±‰ 10072.9811 ä¸‡å¨ = 100,729,811 å¨ï¼ˆä¸€è‡´ï¼‰ |
| `freightTurnover` è´§è¿é‡å‘¨è½¬é‡ | ã€Œé“路运输周转量」的道路货运周转量列；货运量 = å¤§è¡¨ã€Œè§„上 + è§„下」合计 | è§„上+规下（全口径） | å…¨çœå‘¨è½¬é‡ 17,492,129.0479 ä¸‡å¨å…¬é‡Œï¼ˆä¸€è‡´ï¼‰ï¼›å…¨çœè´§è¿é‡ 130,311.89 ä¸‡å¨ = è§„上 31399.8248 + è§„下 98912.0679（一致） |

## ä¸‰ã€å£å¾„差异（不是数据差异，是设计差异）

1. **时点列**：数据查看汇总按用户要求不显示车辆数/企业数/站点数（不做累加）；大表的车辆数等按月取自台账。核对规模指标请回明细或直接看大表对应页。
2. **比率列**：数据查看汇总按累计口径重算（累计同比 = æœ¬æœŸç´¯è®¡ Ã· ä¸Šå¹´åŒæœŸç´¯è®¡ âˆ’ 1；平均运距 = ç´¯è®¡å‘¨è½¬é‡ Ã· ç´¯è®¡å®¢è¿é‡ï¼‰ï¼›å¤§è¡¨æ˜¯é€æœˆåŒæ¯”列 + ç‰ˆå¼å›ºå®šã€‚两者"月度同比"和"累计同比"不能直接互比，需按同一口径取值。
3. **覆盖范围**：数据查看只覆盖**可导入的数据表**（7 ç±»æ”¯æŒæ±‡æ€»ï¼‰ï¼›å¤§è¡¨è¿˜å«ç­çº¿åŒ…车、公路总客运、中口径明细/排名/分析、轨道轮渡、城市汇总/分市州、投资与能耗报表等，这些不在数据查看范围内。
4. **单位**：`h2032` ä¸ºå¨ / å¨å…¬é‡Œï¼Œ`freightTurnover` ä¸Žæ‹†åˆ†è¡¨ä¸ºä¸‡å¨ / ä¸‡å¨å…¬é‡Œï¼Œå¤§è¡¨ç»Ÿä¸€ç”¨ä¸‡å¨ / ä¸‡å¨å…¬é‡Œï¼ˆæ•°æ®æŸ¥çœ‹åˆ—名已标注单位）。

## å››ã€å¤æ ¸æ–¹æ³•ï¼ˆå¯å¤çŽ°ï¼‰

1. `GET /api/report/exportTask/summaryWorkbook?period=2026-08` ç”Ÿæˆ/取缓存 â†’ å– `生成_道路运输量汇总表_2026-08.xlsx`；
2. `GET /api/data/summary?type=<类型>&from=2026-01&to=2026-08` å–汇总；
3. è¿è¡Œ `_tmp_cmp_dabiao2.py`：按大表页签的第 3 è¡Œè¡¨å¤´è¯†åˆ« 2026 å¹´å„月列，逐市州逐指标加总后与汇总接口逐值比对（容差 0.01）。

 docs/ÎÊÌâ»ã×Ü/»ã×Ü´ó±íÎÊÌâ½»½Ó_2026-09-21.md

@@ -241,6 +241,8 @@
| `_chk_all_pref.txt` | 17 å¸‚州两页同比差异清单 |
| `_chk_code*.txt`、`_chk_wyccalc.txt`、`_chk_wycdb.txt`、`_chk_filler.txt`、`_chk_freight.txt` | ç›¸å…³ä»£ç æ®µæ‘˜å½• |

> è¯´æ˜Žï¼ˆ2026-09-27）：上表中的 `_chk_*` è¯æ®ä»¶ä¸ºå½“时的临时文本 dump，已随历史临时文件一并清理（本地不再保留）；如需复现，按本章方法重跑（数据源与步骤见上）。

## 11. å¾…用户/业务确认清单（接手人先别自己拍）

1. ~~P0-1 èµ°æ–¹æ¡ˆ A è¿˜æ˜¯ B？（建议 A）~~ ç”¨æˆ·å·²é€‰æ‹©æ–¹æ¡ˆ A，2026-09-21 å·²å®žæ–½å¹¶å›žå½’通过。

 pack-deploy.ps1

New file
@@ -0,0 +1,98 @@
<#
  ä¸€é”®æ‰“包部署包（含"去密自检"）—— 2026-09-27 æ–°å¢ž
  ç”¨æ³•ï¼š
    powershell -NoProfile -ExecutionPolicy Bypass -File pack-deploy.ps1
    powershell -NoProfile -ExecutionPolicy Bypass -File pack-deploy.ps1 -OutRoot "E:\试验" -SkipFrontend
  åšå››ä»¶äº‹ï¼š
    1) mvn clean package æž„建后端 jar
    2) è§£åŽ‹ jar æ£€æŸ¥å†…ç½® application.yml：必须全是占位符（禁止 sk- å¯†é’¥ / æ˜Žæ–‡å£ä»¤ï¼‰ï¼Œä¸åˆæ ¼ç›´æŽ¥ä¸­æ­¢
    3) npm run build æž„建前端 dist（可 -SkipFrontend）
    4) ç»„装 deploy ç›®å½•ç»“构（backend / frontend / db / README-部署说明.txt），输出到 <OutRoot>\traffic-audit-deploy-<yyyyMMdd>
#>
param(
  [string]$OutRoot = 'E:\试验',
  [switch]$SkipFrontend
)

$ErrorActionPreference = 'Stop'
$root = Split-Path -Parent $MyInvocation.MyCommand.Path
$tplDir = Join-Path $root 'deploy-templates'                  # æ‰“包模板件（已入库，2026-09-27 èµ·ï¼‰
$jarRel = 'traffic-audit-server\target\traffic-audit-server-1.0.0-SNAPSHOT.jar'
$jar = Join-Path $root $jarRel

Write-Host '[1/5] æž„建后端（mvn clean package -DskipTests）...'
Push-Location $root
cmd /c "mvn.cmd -q clean package -DskipTests -f traffic-audit-server\pom.xml > pack-build.log 2>&1"
$rc = $LASTEXITCODE
Pop-Location
if ($rc -ne 0) { throw '后端构建失败，详见 pack-build.log' }
if (-not (Test-Path $jar)) { throw "未找到构建产物：$jar" }
Write-Host ("      äº§ç‰©ï¼š{0:N1} MB" -f ((Get-Item $jar).Length / 1MB))

Write-Host '[2/5] åŽ»å¯†è‡ªæ£€ï¼šè§£åŽ‹ jar æ£€æŸ¥ BOOT-INF/classes/application.yml ...'
Add-Type -AssemblyName System.IO.Compression.FileSystem
$zip = [System.IO.Compression.ZipFile]::OpenRead($jar)
try {
  $entry = $zip.Entries | Where-Object { $_.FullName -eq 'BOOT-INF/classes/application.yml' }
  if (-not $entry) { throw 'jar å†…缺少 BOOT-INF/classes/application.yml' }
  $sr = New-Object System.IO.StreamReader($entry.Open())
  $text = $sr.ReadToEnd()
  $sr.Close()
} finally { $zip.Dispose() }

$bad = @()
if ($text -match 'sk-[A-Za-z0-9]{16,}') { $bad += '疑似明文 API key（sk-…）' }
foreach ($line in ($text -split "`n")) {
  if ($line -match '^\s*(password|api-key|secret)\s*:\s*(.+)$') {
    $v = $matches[2].Trim().Trim('"')
    if ($v -and -not $v.StartsWith('${')) { $bad += ("$($matches[1]) ä¸æ˜¯å ä½ç¬¦") }
  }
}
if ($bad.Count -gt 0) {
  throw ('去密自检未通过：' + ($bad -join '；') + '。请检查 traffic-audit-server\src\main\resources\application.yml')
}
Write-Host '      é€šè¿‡ï¼šjar å†…置配置全部为占位符，无明文密钥/口令。'

Write-Host '[3/5] æž„建前端（npm run build，可 -SkipFrontend è·³è¿‡ï¼‰...'
if (-not $SkipFrontend) {
  Push-Location (Join-Path $root 'traffic-audit-web')
  cmd /c "npm.cmd run build > ..\pack-front.log 2>&1"
  $rc2 = $LASTEXITCODE
  Pop-Location
  if ($rc2 -ne 0) { throw '前端构建失败，详见 pack-front.log' }
  Write-Host '      å‰ç«¯ dist å·²é‡å»º'
}

Write-Host '[4/5] ç»„装部署目录...'
$stamp = Get-Date -Format 'yyyyMMdd'
$dest = Join-Path $OutRoot ("traffic-audit-deploy-" + $stamp)
$n = 2
while (Test-Path $dest) { $dest = Join-Path $OutRoot ("traffic-audit-deploy-" + $stamp + "-" + $n); $n++ }
New-Item -ItemType Directory -Force -Path (Join-Path $dest 'backend'), (Join-Path $dest 'frontend'), (Join-Path $dest 'db') | Out-Null

Copy-Item $jar (Join-Path $dest 'backend') -Force
Copy-Item (Join-Path $tplDir 'backend\application.yml') (Join-Path $dest 'backend') -Force
Copy-Item (Join-Path $tplDir 'backend\start-backend.cmd') (Join-Path $dest 'backend') -Force
Copy-Item (Join-Path $tplDir 'backend\start-backend.sh') (Join-Path $dest 'backend') -Force
Copy-Item (Join-Path $root 'traffic-audit-web\dist') (Join-Path $dest 'frontend') -Recurse -Force
Copy-Item (Join-Path $tplDir 'frontend\nginx.conf.example') (Join-Path $dest 'frontend') -Force
Copy-Item (Join-Path $tplDir 'db\*.sql') (Join-Path $dest 'db') -Force

# docs：运行时模板 + ç”¨æˆ·æ–‡æ¡£ï¼›æŽ’除开发过程文档与缓存/备份（减小体积、避免把内部清单带出去）
$docsDest = Join-Path $dest 'backend\docs'
New-Item -ItemType Directory -Force -Path $docsDest | Out-Null
cmd /c "robocopy `"$root\docs`" `"$docsDest`" /E /NFL /NDL /NJH /NJS /NP /XD _cache å·¥ä½œæ—¥ç»“ åŠŸèƒ½æµ‹è¯•æŠ¥å‘Š é—®é¢˜æ±‡æ€» /XF ç”Ÿæˆ_*.xlsx _bak_* >nul"
if ($LASTEXITCODE -ge 8) { throw "docs å¤åˆ¶å¤±è´¥ï¼ˆrobocopy è¿”回 $LASTEXITCODE）" }
# db è„šæœ¬ä¹Ÿæ”¾ä¸€ä»½åˆ° docs（与旧包一致：docs/init.sql ç­‰ï¼‰
Copy-Item (Join-Path $tplDir 'db\init.sql'), (Join-Path $tplDir 'db\sql_city_bus.sql'), (Join-Path $tplDir 'db\sql_city_taxi.sql'), (Join-Path $tplDir 'db\sql_wyc.sql'), (Join-Path $tplDir 'db\sql_holiday.sql'), (Join-Path $tplDir 'db\sql_holiday_decimal_migration.sql'), (Join-Path $tplDir 'db\sql_holiday_comparison_base_migration.sql') $docsDest -Force -ErrorAction SilentlyContinue

# README：用旧包模板并替换日期占位
$readme = Get-Content (Join-Path $tplDir 'README-部署说明.txt') -Raw -Encoding UTF8
$readme = $readme.Replace('{stamp}', $stamp)
Set-Content -LiteralPath (Join-Path $dest 'README-部署说明.txt') -Value $readme -Encoding UTF8

Write-Host '[5/5] æ±‡æ€»...'
$files = Get-ChildItem $dest -Recurse -File
Write-Host ("      è¾“出目录：{0}" -f $dest)
Write-Host ("      æ–‡ä»¶æ•°ï¼š{0}　合计：{1:N2} MB" -f $files.Count, (($files | Measure-Object Length -Sum).Sum / 1MB))
Write-Host '      æé†’：把包拷到部署机后，只需改 backend\application.yml é‡Œçš„数据库三处 + éœ€è¦æ—¶å¡« deepseek.api-key。'

 set-secrets.ps1

New file
@@ -0,0 +1,31 @@
<#
  è®¾ç½®/更新本机密钥环境变量（值不落文件）—— è½®æ¢ DeepSeek key åŽè·‘这个
  ç”¨æ³•ï¼špowershell -NoProfile -ExecutionPolicy Bypass -File set-secrets.ps1
        ï¼ˆå›žè½¦è·³è¿‡æŸä¸€é¡¹ï¼Œè¡¨ç¤ºä¸æ”¹ï¼‰
#>
$ErrorActionPreference = 'Stop'

function Read-Secret([string]$prompt) {
  $sec = Read-Host -Prompt $prompt -AsSecureString
  if ($null -eq $sec) { return '' }
  $bstr = [Runtime.InteropServices.Marshal]::SecureStringToBSTR($sec)
  try { return [Runtime.InteropServices.Marshal]::PtrToStringBSTR($bstr) }
  finally { [Runtime.InteropServices.Marshal]::ZeroFreeBSTR($bstr) }
}

foreach ($name in @('DEEPSEEK_API_KEY', 'TRAFFIC_DB_PASSWORD')) {
  $cur = [Environment]::GetEnvironmentVariable($name, 'User')
  $hint = if ($cur) { '（已设置，长度 ' + $cur.Length + '）' } else { '（当前未设置）' }
  $val = Read-Secret ("输入 " + $name + " " + $hint + "，直接回车跳过")
  if ([string]::IsNullOrWhiteSpace($val)) { Write-Host ("  è·³è¿‡ " + $name); continue }
  & setx.exe $name $val | Out-Null
  if ($LASTEXITCODE -eq 0) {
    [Environment]::SetEnvironmentVariable($name, $val, 'Process')
    Write-Host ("  å·²æ›´æ–° " + $name)
  } else {
    Write-Host ("  æ›´æ–°å¤±è´¥ï¼š" + $name)
  }
}
Write-Host ''
Write-Host '完成。生效方式：新开的终端自动带上；用 start-dev.ps1 å¯åŠ¨ä¹Ÿä¼šè‡ªåŠ¨ä»Žæ³¨å†Œè¡¨è½½å…¥ã€‚'
Write-Host '（若后端正在运行，请重启后端：停掉 8090 è¿›ç¨‹åŽé‡æ–°æ‰§è¡Œ start-dev.ps1）'

 start-dev.ps1

@@ -12,6 +12,19 @@
$root = Split-Path -Parent $MyInvocation.MyCommand.Path
$webDir = Join-Path $root 'traffic-audit-web'

# ---------- å¯†é’¥ï¼šä»Ž Windows ç”¨æˆ·çŽ¯å¢ƒå˜é‡è¡¥é½ï¼ˆçœŸå®žå€¼ä¸è½æ–‡ä»¶ï¼‰----------
# è‹¥å½“前 shell æ˜¯æ—§è¿›ç¨‹ã€æ‹¿ä¸åˆ°æ–°è®¾çš„变量，则从注册表 HKCU\Environment è¯»ä¸€æ¬¡ï¼Œ
# ä¾›åŽç«¯å­è¿›ç¨‹ç»§æ‰¿ï¼ˆé¿å…"密钥不在任何文件里、又读不到环境变量"的空档）。
foreach ($name in @('TRAFFIC_DB_PASSWORD', 'DEEPSEEK_API_KEY', 'TRAFFIC_DB_URL', 'TRAFFIC_DB_USER', 'TRAFFIC_JWT_SECRET')) {
  if (-not [Environment]::GetEnvironmentVariable($name, 'Process')) {
    $val = [Environment]::GetEnvironmentVariable($name, 'User')
    if ($val) {
      [Environment]::SetEnvironmentVariable($name, $val, 'Process')
      Write-Host "已从用户环境变量载入 $name"
    }
  }
}

function Test-PortListening($port) {
  try {
    $c = Get-NetTCPConnection -LocalPort $port -State Listen -ErrorAction Stop

 traffic-audit-server/src/main/java/com/trafficaudit/holiday/HolidayConstants.java

New file
@@ -0,0 +1,116 @@
package com.trafficaudit.holiday;

import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;

public final class HolidayConstants {
    public static final int COMPARISON_BASE_YEAR = 2026;

    public static final String TYPE_SPRING_FESTIVAL = "SPRING_FESTIVAL";

    public static final String TYPE_LABOR_DAY = "LABOR_DAY";
    public static final String TYPE_NATIONAL_DAY = "NATIONAL_DAY";

    public static final String CATEGORY_HOLIDAY = "HOLIDAY";
    public static final String CATEGORY_NON_HOLIDAY = "NON_HOLIDAY";

    public static final String MODE_RAIL = "RAIL";
    public static final String MODE_CIVIL_AVIATION = "CIVIL_AVIATION";
    public static final String MODE_ROAD = "ROAD";
    public static final String MODE_WATER = "WATER";

    public static final String ROAD_EXPRESSWAY = "EXPRESSWAY";
    public static final String ROAD_NATIONAL_PROVINCIAL = "NATIONAL_PROVINCIAL";

    public static final String VEHICLE_SMALL_PASSENGER = "SMALL_PASSENGER";
    public static final String VEHICLE_MEDIUM_SMALL_PASSENGER = "MEDIUM_SMALL_PASSENGER";

    public static final Map<String, String> HOLIDAY_TYPE_LABELS;
    public static final Map<String, String> DATE_CATEGORY_LABELS;
    public static final Map<String, String> TRANSPORT_MODE_LABELS;
    public static final Map<String, String> ROAD_CATEGORY_LABELS;
    public static final Map<String, String> VEHICLE_TYPE_LABELS;

    private static final Set<String> HOLIDAY_TYPES;
    private static final Set<String> DATE_CATEGORIES;
    private static final Set<String> TRANSPORT_MODES;
    private static final Set<String> ROAD_CATEGORIES;
    private static final Set<String> VEHICLE_TYPES;

    static {
        Map<String, String> holidayTypes = new LinkedHashMap<>();
        holidayTypes.put(TYPE_SPRING_FESTIVAL, "春节");
        holidayTypes.put(TYPE_LABOR_DAY, "五一");
        holidayTypes.put(TYPE_NATIONAL_DAY, "十一");
        HOLIDAY_TYPE_LABELS = Collections.unmodifiableMap(holidayTypes);
        HOLIDAY_TYPES = new LinkedHashSet<>(holidayTypes.keySet());

        Map<String, String> dateCategories = new LinkedHashMap<>();
        dateCategories.put(CATEGORY_HOLIDAY, "节假日");
        dateCategories.put(CATEGORY_NON_HOLIDAY, "非节假日");
        DATE_CATEGORY_LABELS = Collections.unmodifiableMap(dateCategories);
        DATE_CATEGORIES = new LinkedHashSet<>(dateCategories.keySet());

        Map<String, String> transportModes = new LinkedHashMap<>();
        transportModes.put(MODE_RAIL, "铁路");
        transportModes.put(MODE_CIVIL_AVIATION, "民航");
        transportModes.put(MODE_ROAD, "道路");
        transportModes.put(MODE_WATER, "æ°´è·¯");
        TRANSPORT_MODE_LABELS = Collections.unmodifiableMap(transportModes);
        TRANSPORT_MODES = new LinkedHashSet<>(transportModes.keySet());

        Map<String, String> roadCategories = new LinkedHashMap<>();
        roadCategories.put(ROAD_EXPRESSWAY, "高速公路");
        roadCategories.put(ROAD_NATIONAL_PROVINCIAL, "普通国省道");
        ROAD_CATEGORY_LABELS = Collections.unmodifiableMap(roadCategories);
        ROAD_CATEGORIES = new LinkedHashSet<>(roadCategories.keySet());

        Map<String, String> vehicleTypes = new LinkedHashMap<>();
        vehicleTypes.put(VEHICLE_SMALL_PASSENGER, "小客车");
        vehicleTypes.put(VEHICLE_MEDIUM_SMALL_PASSENGER, "中小客车");
        VEHICLE_TYPE_LABELS = Collections.unmodifiableMap(vehicleTypes);
        VEHICLE_TYPES = new LinkedHashSet<>(vehicleTypes.keySet());
    }

    private HolidayConstants() {
    }

    public static boolean supportsComparisonBase(int year) {
        return year == COMPARISON_BASE_YEAR;
    }

    public static boolean isValidHolidayType(String value) {
        return HOLIDAY_TYPES.contains(value);
    }

    public static boolean isValidDateCategory(String value) {
        return DATE_CATEGORIES.contains(value);
    }

    public static boolean isValidTransportMode(String value) {
        return TRANSPORT_MODES.contains(value);
    }

    public static boolean isValidRoadCategory(String value) {
        return ROAD_CATEGORIES.contains(value);
    }

    public static boolean isValidVehicleType(String value) {
        return VEHICLE_TYPES.contains(value);
    }

    public static Map<String, Object> optionMap() {
        Map<String, Object> options = new LinkedHashMap<>();
        options.put("holidayTypes", HOLIDAY_TYPE_LABELS);
        options.put("dateCategories", DATE_CATEGORY_LABELS);
        options.put("transportModes", TRANSPORT_MODE_LABELS);
        options.put("roadCategories", ROAD_CATEGORY_LABELS);
        options.put("vehicleTypes", VEHICLE_TYPE_LABELS);
        options.put("years", Arrays.asList(2024, 2025, 2026));
        return options;
    }
}

 traffic-audit-server/src/main/java/com/trafficaudit/holiday/HolidayNumberUtils.java

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

import org.apache.poi.ss.util.NumberToTextConverter;

import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;

public final class HolidayNumberUtils {

    public static final MathContext EXCEL_MC = new MathContext(15, RoundingMode.HALF_UP);
    public static final BigDecimal ZERO = BigDecimal.ZERO;

    private HolidayNumberUtils() {
    }

    public static BigDecimal excelValue(double value) {
        return normalize(new BigDecimal(NumberToTextConverter.toText(value)));
    }

    public static BigDecimal decimalValue(Object value) {
        if (value == null || value.toString().trim().isEmpty()) return null;
        return normalize(new BigDecimal(value.toString().trim()));
    }

    public static BigDecimal normalize(BigDecimal value) {
        if (value == null) return null;
        BigDecimal rounded = value.round(EXCEL_MC);
        return rounded.signum() == 0 ? ZERO : rounded.stripTrailingZeros();
    }

    public static BigDecimal valueOrZero(BigDecimal value) {
        return value == null ? ZERO : value;
    }

    public static BigDecimal sumNullable(BigDecimal left, BigDecimal right) {
        if (left == null && right == null) return null;
        return normalize(valueOrZero(left).add(valueOrZero(right)));
    }

    public static BigDecimal multiply(BigDecimal left, BigDecimal right) {
        if (left == null || right == null) return null;
        return normalize(left.multiply(right));
    }

    public static BigDecimal divide(BigDecimal dividend, BigDecimal divisor) {
        if (dividend == null || divisor == null || divisor.signum() == 0) return null;
        return normalize(dividend.divide(divisor, EXCEL_MC));
    }

    public static boolean sameValue(BigDecimal left, BigDecimal right) {
        if (left == null || right == null) return false;
        return normalize(left).compareTo(normalize(right)) == 0;
    }

    public static String changeText(BigDecimal value) {
        if (value == null) return "";
        return normalize(value).toPlainString();
    }

    public static String format1(BigDecimal value) {
        if (value == null) return "";
        return value.setScale(1, RoundingMode.HALF_UP).toPlainString();
    }

    public static String format2(BigDecimal value) {
        if (value == null) return "";
        return value.setScale(2, RoundingMode.HALF_UP).toPlainString();
    }
}

 traffic-audit-server/src/main/java/com/trafficaudit/holiday/controller/HolidayConfigController.java

New file
@@ -0,0 +1,95 @@
package com.trafficaudit.holiday.controller;

import com.trafficaudit.common.Result;
import com.trafficaudit.holiday.HolidayConstants;
import com.trafficaudit.holiday.entity.HolidayCalendar;
import com.trafficaudit.holiday.entity.HolidayPassengerCoefficient;
import com.trafficaudit.holiday.service.HolidayConfigService;
import com.trafficaudit.security.utils.JwtUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

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

@RestController
@RequestMapping("/api/holiday/config")
public class HolidayConfigController {

    @Resource
    private HolidayConfigService configService;
    @Resource
    private JwtUtils jwtUtils;

    @GetMapping("/options")
    public Result<Map<String, Object>> options() {
        return Result.ok(HolidayConstants.optionMap());
    }

    @GetMapping("/holidays")
    public Result<List<HolidayCalendar>> holidays(@RequestParam(value = "year", required = false) Integer year,
                                                   @RequestParam(value = "holidayType", required = false) String holidayType) {
        return Result.ok(configService.listHolidays(year, holidayType));
    }

    @PostMapping("/holidays/save")
    public Result<HolidayCalendar> saveHoliday(@RequestHeader(value = "Authorization", required = false) String auth,
                                               @RequestBody Map<String, Object> params) {
        if (!isAdmin(auth)) return Result.error(403, "仅 admin å¯ä»¥ç®¡ç†èŠ‚假日配置");
        try {
            return Result.ok(configService.saveHoliday(params));
        } catch (Exception e) {
            return Result.error(400, e.getMessage());
        }
    }

    @PostMapping("/holidays/delete")
    public Result<Void> deleteHoliday(@RequestHeader(value = "Authorization", required = false) String auth,
                                      @RequestParam("id") Long id) {
        if (!isAdmin(auth)) return Result.error(403, "仅 admin å¯ä»¥ç®¡ç†èŠ‚假日配置");
        try {
            configService.deleteHoliday(id);
            return Result.ok();
        } catch (Exception e) {
            return Result.error(400, e.getMessage());
        }
    }

    @GetMapping("/coefficients")
    public Result<List<HolidayPassengerCoefficient>> coefficients(@RequestParam(value = "year", required = false) Integer year) {
        return Result.ok(configService.listCoefficients(year));
    }

    @PostMapping("/coefficients/save")
    public Result<HolidayPassengerCoefficient> saveCoefficient(@RequestHeader(value = "Authorization", required = false) String auth,
                                                               @RequestBody Map<String, Object> params) {
        if (!isAdmin(auth)) return Result.error(403, "仅 admin å¯ä»¥ç®¡ç†å®¢è¿ç³»æ•°");
        try {
            return Result.ok(configService.saveCoefficient(params));
        } catch (Exception e) {
            return Result.error(400, e.getMessage());
        }
    }

    @PostMapping("/coefficients/delete")
    public Result<Void> deleteCoefficient(@RequestHeader(value = "Authorization", required = false) String auth,
                                          @RequestParam("id") Long id) {
        if (!isAdmin(auth)) return Result.error(403, "仅 admin å¯ä»¥ç®¡ç†å®¢è¿ç³»æ•°");
        try {
            configService.deleteCoefficient(id);
            return Result.ok();
        } catch (Exception e) {
            return Result.error(400, e.getMessage());
        }
    }

    private boolean isAdmin(String auth) {
        return "admin".equals(jwtUtils.resolveUsername(auth));
    }
}

 traffic-audit-server/src/main/java/com/trafficaudit/holiday/controller/HolidayStatController.java

New file
@@ -0,0 +1,82 @@
package com.trafficaudit.holiday.controller;

import com.trafficaudit.common.Result;
import com.trafficaudit.holiday.service.HolidayBulletinService;
import com.trafficaudit.holiday.service.HolidayStatService;
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.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import java.net.URLEncoder;
import java.time.LocalDate;
import java.util.Map;

@RestController
@RequestMapping("/api/holiday")
public class HolidayStatController {

    @Resource
    private HolidayStatService statService;
    @Resource
    private HolidayBulletinService bulletinService;

    @GetMapping("/overview")
    public Result<Map<String, Object>> overview(@RequestParam("year") int year,
                                                 @RequestParam("holidayType") String holidayType) {
        try {
            return Result.ok(statService.overview(year, holidayType));
        } catch (Exception e) {
            return Result.error(400, e.getMessage());
        }
    }

    @PostMapping("/import")
    public Result<Map<String, Object>> importWorkbook(@RequestParam(value = "file", required = false) MultipartFile file,
                                                       @RequestParam("year") int year,
                                                       @RequestParam("holidayType") String holidayType,
                                                       @RequestParam(value = "allowHistoricalOverwrite", defaultValue = "false") boolean allowHistoricalOverwrite) {
        try {
            return Result.ok(statService.importWorkbook(file, year, holidayType, allowHistoricalOverwrite));
        } catch (Exception e) {
            return Result.error(400, e.getMessage());
        }
    }

    @GetMapping("/export")
    public ResponseEntity<byte[]> exportWorkbook(@RequestParam("year") int year,
                                                  @RequestParam("holidayType") String holidayType) throws Exception {
        byte[] data = statService.exportWorkbook(year, holidayType);
        String fileName = year + "å¹´" + holidayTypeFileLabel(holidayType) + "数据.xlsx";
        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/vnd.openxmlformats-officedocument.spreadsheetml.sheet"))
                .body(data);
    }

    @GetMapping("/bulletin")
    public ResponseEntity<byte[]> bulletin(@RequestParam(value = "date", required = false) String date) throws Exception {
        LocalDate targetDate = (date == null || date.trim().isEmpty())
                ? LocalDate.now().minusDays(1) : LocalDate.parse(date);
        byte[] data = bulletinService.generate(targetDate);
        String fileName = String.format("湖北省国庆假期综合运输客流快报（10月%d日）.docx", targetDate.getDayOfMonth());
        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/vnd.openxmlformats-officedocument.wordprocessingml.document"))
                .body(data);
    }

    private String holidayTypeFileLabel(String holidayType) {
        if ("SPRING_FESTIVAL".equals(holidayType)) return "春节";
        if ("LABOR_DAY".equals(holidayType)) return "五一";
        return "十一";
    }
}

 traffic-audit-server/src/main/java/com/trafficaudit/holiday/entity/HolidayCalendar.java

New file
@@ -0,0 +1,22 @@
package com.trafficaudit.holiday.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.LocalDate;
import java.time.LocalDateTime;

@Data
@TableName("holiday_calendar")
public class HolidayCalendar {
    @TableId(type = IdType.AUTO)
    private Long id;
    private Integer year;
    private String holidayType;
    private LocalDate holidayDate;
    private Integer dayIndex;
    private LocalDateTime createdAt;
    private LocalDateTime updatedAt;
}

 traffic-audit-server/src/main/java/com/trafficaudit/holiday/entity/HolidayPassengerCoefficient.java

New file
@@ -0,0 +1,21 @@
package com.trafficaudit.holiday.entity;

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

import java.math.BigDecimal;
import java.time.LocalDateTime;

@Data
@TableName("holiday_passenger_coefficient")
public class HolidayPassengerCoefficient {
    @TableId(type = IdType.AUTO)
    private Long id;
    private Integer year;
    private String dateCategory;
    private BigDecimal coefficient;
    private LocalDateTime createdAt;
    private LocalDateTime updatedAt;
}

 traffic-audit-server/src/main/java/com/trafficaudit/holiday/entity/HolidayPassengerFlow.java

New file
@@ -0,0 +1,23 @@
package com.trafficaudit.holiday.entity;

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

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;

@Data
@TableName("holiday_passenger_flow")
public class HolidayPassengerFlow {
    @TableId(type = IdType.AUTO)
    private Long id;
    private Integer year;
    private LocalDate flowDate;
    private String transportMode;
    private BigDecimal passengerCount;
    private LocalDateTime createdAt;
    private LocalDateTime updatedAt;
}

 traffic-audit-server/src/main/java/com/trafficaudit/holiday/entity/HolidayVehicleFlow.java

New file
@@ -0,0 +1,28 @@
package com.trafficaudit.holiday.entity;

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

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;

@Data
@TableName("holiday_vehicle_flow")
public class HolidayVehicleFlow {
    @TableId(type = IdType.AUTO)
    private Long id;
    private Integer year;
    private LocalDate flowDate;
    private String roadCategory;
    private String vehicleType;
    private BigDecimal vehicleCount;
    @TableField(updateStrategy = FieldStrategy.IGNORED)
    private BigDecimal comparisonBase;
    private LocalDateTime createdAt;
    private LocalDateTime updatedAt;
}

 traffic-audit-server/src/main/java/com/trafficaudit/holiday/mapper/HolidayCalendarMapper.java

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

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

@Mapper
public interface HolidayCalendarMapper extends BaseMapper<HolidayCalendar> {
}

 traffic-audit-server/src/main/java/com/trafficaudit/holiday/mapper/HolidayPassengerCoefficientMapper.java

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

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

@Mapper
public interface HolidayPassengerCoefficientMapper extends BaseMapper<HolidayPassengerCoefficient> {
}

 traffic-audit-server/src/main/java/com/trafficaudit/holiday/mapper/HolidayPassengerFlowMapper.java

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

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

@Mapper
public interface HolidayPassengerFlowMapper extends BaseMapper<HolidayPassengerFlow> {
}

 traffic-audit-server/src/main/java/com/trafficaudit/holiday/mapper/HolidayVehicleFlowMapper.java

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

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

@Mapper
public interface HolidayVehicleFlowMapper extends BaseMapper<HolidayVehicleFlow> {
}

 traffic-audit-server/src/main/java/com/trafficaudit/holiday/service/HolidayBulletinService.java

New file
@@ -0,0 +1,430 @@
package com.trafficaudit.holiday.service;

import com.trafficaudit.holiday.HolidayNumberUtils;
import com.trafficaudit.holiday.service.HolidayStatService.DailyMetrics;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.math.BigDecimal;
import java.nio.file.Files;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;

@Slf4j
@Service
public class HolidayBulletinService {

    private static final String WORD_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
    private static final BigDecimal EPSILON = new BigDecimal("0.0000001");

    @Value("${holiday.bulletin-template:docs/专项统计/重要节假日/湖北省国庆假期综合运输客流快报模板.docx}")
    private String bulletinTemplatePath;

    private final HolidayStatService statService;
    private static final ThreadLocal<Document> CURRENT_DOCUMENT = new ThreadLocal<>();

    public HolidayBulletinService(HolidayStatService statService) {
        this.statService = statService;
    }

    public byte[] generate(LocalDate date) {
        DailyMetrics current = statService.findMetricsByDate(date);
        if (current == null) {
            throw new IllegalArgumentException("所选日期不在已配置的节假日范围内");
        }
        DailyMetrics previousDay = current.getDayIndex() > 1
                ? statService.dailyMetrics(current.getYear(), current.getHolidayType(), current.getDayIndex() - 1) : null;
        DailyMetrics previousYear = statService.dailyMetrics(current.getYear() - 1, current.getHolidayType(), current.getDayIndex());
        DailyMetrics currentCumulative = statService.cumulativeMetrics(current.getYear(), current.getHolidayType(), current.getDayIndex());
        DailyMetrics previousYearCumulative = statService.cumulativeMetrics(current.getYear() - 1, current.getHolidayType(), current.getDayIndex());

        if (current.getTotalPersonFlow() == null) {
            throw new IllegalArgumentException("所选日期的全社会跨区域人员流动量没有足够数据，无法生成快报");
        }

        String currentTotal = formatNumber(current.getTotalPersonFlow());
        String cumulativeTotalYi = formatNumber(currentCumulative.getTotalPersonFlow() == null
                ? null : HolidayNumberUtils.divide(currentCumulative.getTotalPersonFlow(), BigDecimal.valueOf(10000)));
        String ringRatioClause = previousDay == null ? "" : "，环比" + ratioPhrase(
                current.getTotalPersonFlow(), previousDay.getTotalPersonFlow());
        String paragraph1 = String.format("%d月%d日（假期第%d天），全省全社会跨区域人员流动量%s万人次%s，比2025年同期%s。",
                date.getMonthValue(), date.getDayOfMonth(), current.getDayIndex(), currentTotal,
                ringRatioClause,
                ratioPhrase(current.getTotalPersonFlow(), previousYear == null ? null : previousYear.getTotalPersonFlow()));
        String paragraph2 = String.format("假期以来，全省全社会跨区域人员流动量累计%s亿人次，比2025年同期%s。",
                cumulativeTotalYi,
                ratioPhrase(currentCumulative.getTotalPersonFlow(),
                        previousYearCumulative == null ? null : previousYearCumulative.getTotalPersonFlow()));

        File template = resolveTemplateFile();
        if (!template.exists() || !template.isFile()) {
            throw new IllegalArgumentException("快报模板文件不存在: " + template.getAbsolutePath());
        }

        try {
            byte[] templateBytes;
            try (InputStream in = new FileInputStream(template)) {
                templateBytes = readAll(in);
            }
            byte[] documentXml = readZipEntry(templateBytes, "word/document.xml");
            Document document = parseDocument(documentXml);
            CURRENT_DOCUMENT.set(document);
            try {
                replaceParagraph(document, text -> text.startsWith("10月") && text.contains("假期第"), paragraph1);
                replaceParagraph(document, text -> text.startsWith("假期以来"), paragraph2);
                fillTable(document, current, previousDay, previousYear, currentCumulative, previousYearCumulative);
                byte[] replacedXml = serializeDocument(document);
                return replaceZipEntry(templateBytes, "word/document.xml", replacedXml);
            } finally {
                CURRENT_DOCUMENT.remove();
            }
        } catch (Exception e) {
            throw new IllegalArgumentException("快报生成失败: " + e.getMessage(), e);
        }
    }

    private void fillTable(Document document, DailyMetrics current, DailyMetrics previousDay,
                           DailyMetrics previousYear, DailyMetrics currentCumulative,
                           DailyMetrics previousYearCumulative) {
        Element table = firstElement(document, "tbl");
        if (table == null) {
            throw new IllegalArgumentException("快报模板中找不到数据表");
        }
        writeTableRow(table, 2, new String[]{
                number(current.getNonBusinessPersonFlow()),
                ratio(current.getNonBusinessPersonFlow(), previousDay == null ? null : previousDay.getNonBusinessPersonFlow()),
                ratio(current.getNonBusinessPersonFlow(), previousYear == null ? null : previousYear.getNonBusinessPersonFlow()),
                "—",
                number(currentCumulative.getNonBusinessPersonFlow()),
                ratio(currentCumulative.getNonBusinessPersonFlow(),
                        previousYearCumulative == null ? null : previousYearCumulative.getNonBusinessPersonFlow()),
                "—"
        });
        writeTableRow(table, 3, new String[]{
                number(current.getRoad()),
                ratio(current.getRoad(), previousDay == null ? null : previousDay.getRoad()),
                ratio(current.getRoad(), previousYear == null ? null : previousYear.getRoad()),
                "—",
                number(currentCumulative.getRoad()),
                ratio(currentCumulative.getRoad(), previousYearCumulative == null ? null : previousYearCumulative.getRoad()),
                "—"
        });
        writeTableRow(table, 4, new String[]{
                number(current.getRoadPersonFlow()),
                ratio(current.getRoadPersonFlow(), previousDay == null ? null : previousDay.getRoadPersonFlow()),
                ratio(current.getRoadPersonFlow(), previousYear == null ? null : previousYear.getRoadPersonFlow()),
                "—",
                number(currentCumulative.getRoadPersonFlow()),
                ratio(currentCumulative.getRoadPersonFlow(), previousYearCumulative == null ? null : previousYearCumulative.getRoadPersonFlow()),
                "—"
        });
        writeTableRow(table, 5, transportRow(current.getRail(), previousDay == null ? null : previousDay.getRail(),
                previousYear == null ? null : previousYear.getRail(), currentCumulative.getRail(),
                previousYearCumulative == null ? null : previousYearCumulative.getRail()));
        writeTableRow(table, 6, transportRow(current.getCivilAviation(), previousDay == null ? null : previousDay.getCivilAviation(),
                previousYear == null ? null : previousYear.getCivilAviation(), currentCumulative.getCivilAviation(),
                previousYearCumulative == null ? null : previousYearCumulative.getCivilAviation()));
        writeTableRow(table, 7, transportRow(current.getWater(), previousDay == null ? null : previousDay.getWater(),
                previousYear == null ? null : previousYear.getWater(), currentCumulative.getWater(),
                previousYearCumulative == null ? null : previousYearCumulative.getWater()));
        writeTableRow(table, 8, transportRow(current.getTotalPersonFlow(), previousDay == null ? null : previousDay.getTotalPersonFlow(),
                previousYear == null ? null : previousYear.getTotalPersonFlow(), currentCumulative.getTotalPersonFlow(),
                previousYearCumulative == null ? null : previousYearCumulative.getTotalPersonFlow()));
    }

    private String[] transportRow(BigDecimal current, BigDecimal previousDay, BigDecimal previousYear,
                                  BigDecimal currentCumulative, BigDecimal previousYearCumulative) {
        return new String[]{
                number(current),
                ratio(current, previousDay),
                ratio(current, previousYear),
                "—",
                number(currentCumulative),
                ratio(currentCumulative, previousYearCumulative),
                "—"
        };
    }

    private void writeTableRow(Element table, int rowIndex, String[] values) {
        List<Element> rows = childElements(table, "tr");
        if (rowIndex >= rows.size()) return;
        Element row = rows.get(rowIndex);
        List<Element> cells = cellRefs(row);
        int logicalColumn = 0;
        for (Element cell : cells) {
            int span = gridSpan(cell);
            if (logicalColumn >= 2 && logicalColumn < 9) {
                int valueIndex = logicalColumn - 2;
                if (valueIndex < values.length) {
                    setCellText(cell, values[valueIndex]);
                }
            }
            logicalColumn += span;
        }
    }

    private List<Element> cellRefs(Element row) {
        List<Element> cells = new ArrayList<>();
        for (Element child : childElements(row, "tc")) cells.add(child);
        return cells;
    }

    private int gridSpan(Element cell) {
        Element tcPr = firstChildElement(cell, "tcPr");
        if (tcPr == null) return 1;
        Element span = firstChildElement(tcPr, "gridSpan");
        if (span == null) return 1;
        String value = span.getAttributeNS(WORD_NS, "val");
        try {
            return Integer.parseInt(value);
        } catch (Exception e) {
            return 1;
        }
    }

    private void setCellText(Element cell, String text) {
        Element tcPr = firstChildElement(cell, "tcPr");
        Element templateParagraph = firstChildElement(cell, "p");
        Element paragraph = createElement("p");
        if (templateParagraph != null) {
            Element pPr = firstChildElement(templateParagraph, "pPr");
            if (pPr != null) paragraph.appendChild(pPr.cloneNode(true));
        }
        Element run = createElement("r");
        Element t = createElement("t");
        t.setAttributeNS("http://www.w3.org/XML/1998/namespace", "xml:space", "preserve");
        t.setTextContent(text == null ? "" : text);
        run.appendChild(t);
        paragraph.appendChild(run);

        List<Node> removals = new ArrayList<>();
        Node child = cell.getFirstChild();
        while (child != null) {
            Node next = child.getNextSibling();
            if (child instanceof Element && "p".equals(localName(child))) {
                removals.add(child);
            }
            child = next;
        }
        for (Node node : removals) cell.removeChild(node);
        if (tcPr != null && tcPr.getNextSibling() != null) {
            cell.insertBefore(paragraph, tcPr.getNextSibling());
        } else if (tcPr != null) {
            cell.appendChild(paragraph);
        } else {
            cell.insertBefore(paragraph, cell.getFirstChild());
        }
    }

    private void replaceParagraph(Document document, ParagraphMatcher matcher, String replacement) {
        NodeList paragraphs = document.getElementsByTagNameNS(WORD_NS, "p");
        for (int i = 0; i < paragraphs.getLength(); i++) {
            Element paragraph = (Element) paragraphs.item(i);
            String text = paragraphText(paragraph);
            if (matcher.matches(text)) {
                setParagraphText(paragraph, replacement);
                return;
            }
        }
        throw new IllegalArgumentException("快报模板缺少可替换段落: " + replacement);
    }

    private void setParagraphText(Element paragraph, String text) {
        Element pPr = firstChildElement(paragraph, "pPr");
        Element firstRun = firstChildElement(paragraph, "r");
        Element rPr = firstRun == null ? null : firstChildElement(firstRun, "rPr");
        List<Node> removals = new ArrayList<>();
        Node child = paragraph.getFirstChild();
        while (child != null) {
            Node next = child.getNextSibling();
            if (child != pPr) removals.add(child);
            child = next;
        }
        for (Node node : removals) paragraph.removeChild(node);

        Element run = createElement("r");
        if (rPr != null) run.appendChild(rPr.cloneNode(true));
        Element t = createElement("t");
        t.setAttributeNS("http://www.w3.org/XML/1998/namespace", "xml:space", "preserve");
        t.setTextContent(text);
        run.appendChild(t);
        paragraph.appendChild(run);
    }

    private String paragraphText(Element paragraph) {
        StringBuilder builder = new StringBuilder();
        NodeList texts = paragraph.getElementsByTagNameNS(WORD_NS, "t");
        for (int i = 0; i < texts.getLength(); i++) {
            builder.append(texts.item(i).getTextContent());
        }
        return builder.toString();
    }

    private String ratioPhrase(BigDecimal current, BigDecimal base) {
        if (current == null || base == null || base.abs().compareTo(EPSILON) < 0) return "无可比数据";
        BigDecimal ratio = HolidayNumberUtils.divide(current, base);
        BigDecimal percent = HolidayNumberUtils.multiply(ratio.subtract(BigDecimal.ONE), BigDecimal.valueOf(100));
        if (percent == null || percent.abs().compareTo(EPSILON) < 0) return "持平";
        return (percent.signum() > 0 ? "增长" : "下降") + HolidayNumberUtils.format1(percent.abs()) + "%";
    }

    private String ratio(BigDecimal current, BigDecimal base) {
        if (current == null || base == null || base.abs().compareTo(EPSILON) < 0) return "—";
        return ratioPhrase(current, base);
    }

    private String number(BigDecimal value) {
        return value == null ? "—" : formatNumber(value);
    }

    private String formatNumber(BigDecimal value) {
        if (value == null) return "";
        return HolidayNumberUtils.format2(value);
    }

    private File resolveTemplateFile() {
        List<File> candidates = new ArrayList<>();
        File configured = new File(bulletinTemplatePath);
        candidates.add(configured);
        if (!configured.isAbsolute()) {
            candidates.add(new File(System.getProperty("user.dir"), bulletinTemplatePath));
            candidates.add(new File(System.getProperty("user.dir"), "../" + bulletinTemplatePath));
        }
        for (File candidate : candidates) {
            try {
                if (candidate.exists() && candidate.isFile()) {
                    return candidate.getCanonicalFile();
                }
            } catch (Exception ignored) {
                // Keep checking.
            }
        }
        return configured;
    }

    private byte[] readZipEntry(byte[] zipBytes, String entryName) throws Exception {
        try (ZipInputStream zin = new ZipInputStream(new ByteArrayInputStream(zipBytes))) {
            ZipEntry entry;
            while ((entry = zin.getNextEntry()) != null) {
                if (entryName.equals(entry.getName())) {
                    return readAll(zin);
                }
            }
        }
        throw new IllegalArgumentException("模板中缺少 " + entryName);
    }

    private byte[] replaceZipEntry(byte[] zipBytes, String entryName, byte[] replacement) throws Exception {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        try (ZipInputStream zin = new ZipInputStream(new ByteArrayInputStream(zipBytes));
             ZipOutputStream zout = new ZipOutputStream(out)) {
            ZipEntry entry;
            byte[] buffer = new byte[8192];
            while ((entry = zin.getNextEntry()) != null) {
                ZipEntry target = new ZipEntry(entry.getName());
                zout.putNextEntry(target);
                if (entryName.equals(entry.getName())) {
                    zout.write(replacement);
                } else {
                    int length;
                    while ((length = zin.read(buffer)) > 0) {
                        zout.write(buffer, 0, length);
                    }
                }
                zout.closeEntry();
            }
        }
        return out.toByteArray();
    }

    private Document parseDocument(byte[] xml) throws Exception {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        factory.setNamespaceAware(true);
        return factory.newDocumentBuilder().parse(new ByteArrayInputStream(xml));
    }

    private byte[] serializeDocument(Document document) throws Exception {
        Transformer transformer = TransformerFactory.newInstance().newTransformer();
        transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
        transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no");
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        transformer.transform(new DOMSource(document), new StreamResult(out));
        return out.toByteArray();
    }

    private Element firstElement(Document document, String localName) {
        NodeList list = document.getElementsByTagNameNS(WORD_NS, localName);
        return list.getLength() == 0 ? null : (Element) list.item(0);
    }

    private Element createElement(String localName) {
        Document document = CURRENT_DOCUMENT.get();
        if (document == null) {
            throw new IllegalStateException("Word document is not initialized");
        }
        return document.createElementNS(WORD_NS, "w:" + localName);
    }

    private List<Element> childElements(Element parent, String localName) {
        List<Element> result = new ArrayList<>();
        Node child = parent.getFirstChild();
        while (child != null) {
            if (child instanceof Element && localName.equals(localName(child))) {
                result.add((Element) child);
            }
            child = child.getNextSibling();
        }
        return result;
    }

    private Element firstChildElement(Element parent, String localName) {
        Node child = parent.getFirstChild();
        while (child != null) {
            if (child instanceof Element && localName.equals(localName(child))) {
                return (Element) child;
            }
            child = child.getNextSibling();
        }
        return null;
    }

    private String localName(Node node) {
        return node.getLocalName() == null ? node.getNodeName().replaceFirst("^.*:", "") : node.getLocalName();
    }

    private byte[] readAll(InputStream in) throws Exception {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        byte[] buffer = new byte[8192];
        int length;
        while ((length = in.read(buffer)) > 0) {
            out.write(buffer, 0, length);
        }
        return out.toByteArray();
    }

    private interface ParagraphMatcher {
        boolean matches(String text);
    }
}

 traffic-audit-server/src/main/java/com/trafficaudit/holiday/service/HolidayConfigService.java

New file
@@ -0,0 +1,202 @@
package com.trafficaudit.holiday.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.trafficaudit.holiday.HolidayConstants;
import com.trafficaudit.holiday.entity.HolidayCalendar;
import com.trafficaudit.holiday.entity.HolidayPassengerCoefficient;
import com.trafficaudit.holiday.mapper.HolidayCalendarMapper;
import com.trafficaudit.holiday.mapper.HolidayPassengerCoefficientMapper;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;

@Service
public class HolidayConfigService {

    @Resource
    private HolidayCalendarMapper holidayCalendarMapper;

    @Resource
    private HolidayPassengerCoefficientMapper coefficientMapper;

    public List<HolidayCalendar> listHolidays(Integer year, String holidayType) {
        LambdaQueryWrapper<HolidayCalendar> wrapper = new LambdaQueryWrapper<HolidayCalendar>()
                .eq(year != null, HolidayCalendar::getYear, year)
                .eq(holidayType != null && !holidayType.trim().isEmpty(), HolidayCalendar::getHolidayType, holidayType)
                .orderByAsc(HolidayCalendar::getYear)
                .orderByAsc(HolidayCalendar::getHolidayType)
                .orderByAsc(HolidayCalendar::getDayIndex);
        return holidayCalendarMapper.selectList(wrapper);
    }

    public List<HolidayCalendar> findHolidayDays(int year, String holidayType) {
        return holidayCalendarMapper.selectList(new LambdaQueryWrapper<HolidayCalendar>()
                .eq(HolidayCalendar::getYear, year)
                .eq(HolidayCalendar::getHolidayType, holidayType)
                .orderByAsc(HolidayCalendar::getDayIndex));
    }

    public HolidayCalendar findHolidayByDate(LocalDate date) {
        return holidayCalendarMapper.selectOne(new LambdaQueryWrapper<HolidayCalendar>()
                .eq(HolidayCalendar::getHolidayDate, date)
                .orderByAsc(HolidayCalendar::getDayIndex)
                .last("limit 1"));
    }

    @Transactional
    public HolidayCalendar saveHoliday(Map<String, Object> params) {
        Long id = longValue(params.get("id"));
        Integer year = intValue(params.get("year"));
        String holidayType = stringValue(params.get("holidayType"));
        LocalDate holidayDate = dateValue(params.get("holidayDate"));
        Integer dayIndex = intValue(params.get("dayIndex"));
        if (year == null || year < 2000 || year > 2100) {
            throw new IllegalArgumentException("年份不正确");
        }
        if (!HolidayConstants.isValidHolidayType(holidayType)) {
            throw new IllegalArgumentException("节假日分类不正确");
        }
        if (holidayDate == null || holidayDate.getYear() != year) {
            throw new IllegalArgumentException("日期必须属于所选年份");
        }
        if (dayIndex == null || dayIndex < 1) {
            throw new IllegalArgumentException("第几日必须从 1 å¼€å§‹");
        }
        LambdaQueryWrapper<HolidayCalendar> duplicate = new LambdaQueryWrapper<HolidayCalendar>()
                .eq(HolidayCalendar::getYear, year)
                .eq(HolidayCalendar::getHolidayType, holidayType)
                .and(w -> w.eq(HolidayCalendar::getHolidayDate, holidayDate)
                        .or().eq(HolidayCalendar::getDayIndex, dayIndex));
        if (id != null) {
            duplicate.ne(HolidayCalendar::getId, id);
        }
        if (holidayCalendarMapper.selectCount(duplicate) > 0) {
            throw new IllegalArgumentException("同一节假日下的日期或第几日已存在");
        }

        HolidayCalendar entity = id == null ? new HolidayCalendar() : holidayCalendarMapper.selectById(id);
        if (entity == null) {
            throw new IllegalArgumentException("节假日记录不存在");
        }
        if (id == null) {
            entity.setCreatedAt(LocalDateTime.now());
        }
        entity.setYear(year);
        entity.setHolidayType(holidayType);
        entity.setHolidayDate(holidayDate);
        entity.setDayIndex(dayIndex);
        entity.setUpdatedAt(LocalDateTime.now());
        if (id == null) {
            holidayCalendarMapper.insert(entity);
        } else {
            holidayCalendarMapper.updateById(entity);
        }
        return entity;
    }

    @Transactional
    public void deleteHoliday(Long id) {
        if (id == null) {
            throw new IllegalArgumentException("缺少记录 id");
        }
        holidayCalendarMapper.deleteById(id);
    }

    public List<HolidayPassengerCoefficient> listCoefficients(Integer year) {
        return coefficientMapper.selectList(new LambdaQueryWrapper<HolidayPassengerCoefficient>()
                .eq(year != null, HolidayPassengerCoefficient::getYear, year)
                .orderByAsc(HolidayPassengerCoefficient::getYear)
                .orderByAsc(HolidayPassengerCoefficient::getDateCategory));
    }

    public BigDecimal coefficientOf(int year, String dateCategory) {
        HolidayPassengerCoefficient row = coefficientMapper.selectOne(
                new LambdaQueryWrapper<HolidayPassengerCoefficient>()
                        .eq(HolidayPassengerCoefficient::getYear, year)
                        .eq(HolidayPassengerCoefficient::getDateCategory, dateCategory)
                        .last("limit 1"));
        return row == null ? null : row.getCoefficient();
    }

    @Transactional
    public HolidayPassengerCoefficient saveCoefficient(Map<String, Object> params) {
        Long id = longValue(params.get("id"));
        Integer year = intValue(params.get("year"));
        String dateCategory = stringValue(params.get("dateCategory"));
        BigDecimal coefficient = decimalValue(params.get("coefficient"));
        if (year == null || year < 2000 || year > 2100) {
            throw new IllegalArgumentException("年份不正确");
        }
        if (!HolidayConstants.isValidDateCategory(dateCategory)) {
            throw new IllegalArgumentException("日期分类不正确");
        }
        if (coefficient == null || coefficient.compareTo(BigDecimal.ZERO) <= 0) {
            throw new IllegalArgumentException("客运系数必须大于 0");
        }
        LambdaQueryWrapper<HolidayPassengerCoefficient> duplicate = new LambdaQueryWrapper<HolidayPassengerCoefficient>()
                .eq(HolidayPassengerCoefficient::getYear, year)
                .eq(HolidayPassengerCoefficient::getDateCategory, dateCategory);
        if (id != null) {
            duplicate.ne(HolidayPassengerCoefficient::getId, id);
        }
        if (coefficientMapper.selectCount(duplicate) > 0) {
            throw new IllegalArgumentException("该年份和日期分类的客运系数已存在");
        }

        HolidayPassengerCoefficient entity = id == null ? new HolidayPassengerCoefficient() : coefficientMapper.selectById(id);
        if (entity == null) {
            throw new IllegalArgumentException("客运系数记录不存在");
        }
        if (id == null) {
            entity.setCreatedAt(LocalDateTime.now());
        }
        entity.setYear(year);
        entity.setDateCategory(dateCategory);
        entity.setCoefficient(coefficient);
        entity.setUpdatedAt(LocalDateTime.now());
        if (id == null) {
            coefficientMapper.insert(entity);
        } else {
            coefficientMapper.updateById(entity);
        }
        return entity;
    }

    @Transactional
    public void deleteCoefficient(Long id) {
        if (id == null) {
            throw new IllegalArgumentException("缺少记录 id");
        }
        coefficientMapper.deleteById(id);
    }

    private Long longValue(Object value) {
        if (value == null || value.toString().trim().isEmpty()) return null;
        return Long.valueOf(value.toString());
    }

    private Integer intValue(Object value) {
        if (value == null || value.toString().trim().isEmpty()) return null;
        return Integer.valueOf(value.toString());
    }

    private BigDecimal decimalValue(Object value) {
        if (value == null || value.toString().trim().isEmpty()) return null;
        return com.trafficaudit.holiday.HolidayNumberUtils.decimalValue(value);
    }

    private String stringValue(Object value) {
        return value == null ? null : value.toString().trim();
    }

    private LocalDate dateValue(Object value) {
        if (value == null || value.toString().trim().isEmpty()) return null;
        return LocalDate.parse(value.toString());
    }
}

 traffic-audit-server/src/main/java/com/trafficaudit/holiday/service/HolidayReferenceDataInitializer.java

New file
@@ -0,0 +1,21 @@
package com.trafficaudit.holiday.service;

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

@Component
@Order(100)
public class HolidayReferenceDataInitializer implements ApplicationRunner {

    @Resource
    private HolidayWorkbookService workbookService;

    @Override
    public void run(ApplicationArguments args) {
        workbookService.seedReferenceDataIfNeeded();
    }
}

 traffic-audit-server/src/main/java/com/trafficaudit/holiday/service/HolidayStatService.java

New file
@@ -0,0 +1,297 @@
package com.trafficaudit.holiday.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.trafficaudit.dataimport.entity.ImportBatch;
import com.trafficaudit.dataimport.mapper.ImportBatchMapper;
import com.trafficaudit.holiday.HolidayConstants;
import com.trafficaudit.holiday.HolidayNumberUtils;
import com.trafficaudit.holiday.entity.HolidayCalendar;
import com.trafficaudit.holiday.entity.HolidayPassengerFlow;
import com.trafficaudit.holiday.entity.HolidayVehicleFlow;
import com.trafficaudit.holiday.mapper.HolidayPassengerFlowMapper;
import com.trafficaudit.holiday.mapper.HolidayVehicleFlowMapper;
import lombok.Data;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

@Service
public class HolidayStatService {

    @Resource
    private HolidayConfigService configService;
    @Resource
    private HolidayWorkbookService workbookService;
    @Resource
    private HolidayPassengerFlowMapper passengerFlowMapper;
    @Resource
    private HolidayVehicleFlowMapper vehicleFlowMapper;
    @Resource
    private ImportBatchMapper importBatchMapper;

    public Map<String, Object> overview(int year, String holidayType) {
        List<HolidayCalendar> calendar = configService.findHolidayDays(year, holidayType);
        Map<String, Object> result = new LinkedHashMap<>();
        result.put("year", year);
        result.put("holidayType", holidayType);
        result.put("holidayTypeLabel", HolidayConstants.HOLIDAY_TYPE_LABELS.get(holidayType));
        result.put("days", calendar);
        result.put("rows", buildOverviewRows(year, holidayType, calendar));
        result.put("templateFileName", workbookService.referenceFileName());
        return result;
    }

    @Transactional
    public Map<String, Object> importWorkbook(MultipartFile file, int year, String holidayType, boolean allowHistoricalOverwrite) {
        HolidayWorkbookService.ImportSummary summary = workbookService.importWorkbook(file, year, holidayType, allowHistoricalOverwrite);
        if (summary.isConfirmationRequired()) {
            return importResult(summary);
        }
        ImportBatch batch = new ImportBatch();
        batch.setFileName(file == null ? null : file.getOriginalFilename());
        batch.setImportType("HOLIDAY_FLOW");
        batch.setReportPeriod(year + "-" + holidayType);
        batch.setTotalRows(summary.getSuccessRows() + summary.getFailRows());
        batch.setSuccessRows(summary.getSuccessRows());
        batch.setFailRows(summary.getFailRows());
        batch.setErrorDetail(joinErrors(summary.getErrors()));
        batch.setCreatedAt(LocalDateTime.now());
        importBatchMapper.insert(batch);

        return importResult(summary);
    }

    private Map<String, Object> importResult(HolidayWorkbookService.ImportSummary summary) {
        Map<String, Object> result = new LinkedHashMap<>();
        result.put("passengerRows", summary.getPassengerRows());
        result.put("vehicleRows", summary.getVehicleRows());
        result.put("skippedRows", summary.getSkippedRows());
        result.put("successRows", summary.getSuccessRows());
        result.put("failRows", summary.getFailRows());
        result.put("errors", summary.getErrors());
        result.put("confirmationRequired", summary.isConfirmationRequired());
        result.put("historicalChanges", summary.getHistoricalChanges());
        return result;
    }

    public byte[] exportWorkbook(int year, String holidayType) {
        return workbookService.exportWorkbook(year, holidayType);
    }

    public List<Map<String, Object>> buildOverviewRows(int year, String holidayType, List<HolidayCalendar> calendar) {
        Map<LocalDate, Map<String, BigDecimal>> passengerByDate = loadPassengerByDate(year);
        Map<LocalDate, Map<String, BigDecimal>> vehicleByDate = loadVehicleByDate(year);
        Map<LocalDate, BigDecimal> comparisonBaseByDate = loadComparisonBaseByDate(year);
        BigDecimal coefficient = configService.coefficientOf(year, HolidayConstants.CATEGORY_HOLIDAY);
        List<Map<String, Object>> rows = new ArrayList<>();
        BigDecimal previousNationalProvincial = null;
        for (HolidayCalendar day : calendar) {
            Map<String, BigDecimal> passenger = passengerByDate.getOrDefault(day.getHolidayDate(), Collections.emptyMap());
            Map<String, BigDecimal> vehicle = vehicleByDate.getOrDefault(day.getHolidayDate(), Collections.emptyMap());
            BigDecimal expressway = vehicle.get(HolidayConstants.ROAD_EXPRESSWAY);
            BigDecimal nationalProvincial = vehicle.get(HolidayConstants.ROAD_NATIONAL_PROVINCIAL);
            BigDecimal comparisonBase = comparisonBaseByDate.get(day.getHolidayDate());
            BigDecimal nationalProvincialRingRatio = nationalProvincialRingRatio(
                    year, nationalProvincial, previousNationalProvincial, comparisonBase);
            BigDecimal nonBusinessPersonFlow = null;
            if (coefficient != null && (expressway != null || nationalProvincial != null)) {
                nonBusinessPersonFlow = HolidayNumberUtils.multiply(
                        HolidayNumberUtils.sumNullable(expressway, nationalProvincial), coefficient);
            }
            Map<String, Object> row = new LinkedHashMap<>();
            row.put("dayIndex", day.getDayIndex());
            row.put("date", day.getHolidayDate());
            row.put("rail", passenger.get(HolidayConstants.MODE_RAIL));
            row.put("civilAviation", passenger.get(HolidayConstants.MODE_CIVIL_AVIATION));
            row.put("road", passenger.get(HolidayConstants.MODE_ROAD));
            row.put("water", passenger.get(HolidayConstants.MODE_WATER));
            row.put("expressway", expressway);
            row.put("nationalProvincial", nationalProvincial);
            row.put("comparisonBase", comparisonBase);
            row.put("nationalProvincialRingRatio", nationalProvincialRingRatio);
            row.put("coefficient", coefficient);
            row.put("nonBusinessPersonFlow", nonBusinessPersonFlow);
            row.put("totalPersonFlow", totalPersonFlow(passenger, nonBusinessPersonFlow));
            rows.add(row);
            previousNationalProvincial = nationalProvincial;
        }
        return rows;
    }

    public DailyMetrics dailyMetrics(int year, String holidayType, int dayIndex) {
        List<HolidayCalendar> calendar = configService.findHolidayDays(year, holidayType);
        HolidayCalendar target = null;
        for (HolidayCalendar day : calendar) {
            if (day.getDayIndex() != null && day.getDayIndex() == dayIndex) {
                target = day;
                break;
            }
        }
        if (target == null) return null;

        Map<LocalDate, Map<String, BigDecimal>> passengerByDate = loadPassengerByDate(year);
        Map<LocalDate, Map<String, BigDecimal>> vehicleByDate = loadVehicleByDate(year);
        Map<LocalDate, BigDecimal> comparisonBaseByDate = loadComparisonBaseByDate(year);
        Map<String, BigDecimal> passenger = passengerByDate.getOrDefault(target.getHolidayDate(), Collections.emptyMap());
        Map<String, BigDecimal> vehicle = vehicleByDate.getOrDefault(target.getHolidayDate(), Collections.emptyMap());
        BigDecimal coefficient = configService.coefficientOf(year, HolidayConstants.CATEGORY_HOLIDAY);
        BigDecimal expressway = vehicle.get(HolidayConstants.ROAD_EXPRESSWAY);
        BigDecimal nationalProvincial = vehicle.get(HolidayConstants.ROAD_NATIONAL_PROVINCIAL);
        BigDecimal comparisonBase = comparisonBaseByDate.get(target.getHolidayDate());
        BigDecimal nonBusiness = null;
        if (coefficient != null && (expressway != null || nationalProvincial != null)) {
            nonBusiness = HolidayNumberUtils.multiply(
                    HolidayNumberUtils.sumNullable(expressway, nationalProvincial), coefficient);
        }

        DailyMetrics metrics = new DailyMetrics();
        metrics.setYear(year);
        metrics.setHolidayType(holidayType);
        metrics.setDayIndex(dayIndex);
        metrics.setDate(target.getHolidayDate());
        metrics.setRail(passenger.get(HolidayConstants.MODE_RAIL));
        metrics.setCivilAviation(passenger.get(HolidayConstants.MODE_CIVIL_AVIATION));
        metrics.setRoad(passenger.get(HolidayConstants.MODE_ROAD));
        metrics.setWater(passenger.get(HolidayConstants.MODE_WATER));
        metrics.setExpressway(expressway);
        metrics.setNationalProvincial(nationalProvincial);
        metrics.setComparisonBase(comparisonBase);
        metrics.setCoefficient(coefficient);
        metrics.setNonBusinessPersonFlow(nonBusiness);
        metrics.setRoadPersonFlow(sumNullable(metrics.getRoad(), nonBusiness));
        metrics.setTotalPersonFlow(totalPersonFlow(passenger, nonBusiness));
        return metrics;
    }

    public DailyMetrics cumulativeMetrics(int year, String holidayType, int dayIndex) {
        DailyMetrics cumulative = new DailyMetrics();
        cumulative.setYear(year);
        cumulative.setHolidayType(holidayType);
        cumulative.setDayIndex(dayIndex);
        for (int day = 1; day <= dayIndex; day++) {
            DailyMetrics item = dailyMetrics(year, holidayType, day);
            if (item == null) continue;
            cumulative.setRail(sumNullable(cumulative.getRail(), item.getRail()));
            cumulative.setCivilAviation(sumNullable(cumulative.getCivilAviation(), item.getCivilAviation()));
            cumulative.setRoad(sumNullable(cumulative.getRoad(), item.getRoad()));
            cumulative.setWater(sumNullable(cumulative.getWater(), item.getWater()));
            cumulative.setExpressway(sumNullable(cumulative.getExpressway(), item.getExpressway()));
            cumulative.setNationalProvincial(sumNullable(cumulative.getNationalProvincial(), item.getNationalProvincial()));
            cumulative.setNonBusinessPersonFlow(sumNullable(cumulative.getNonBusinessPersonFlow(), item.getNonBusinessPersonFlow()));
            cumulative.setRoadPersonFlow(sumNullable(cumulative.getRoadPersonFlow(), item.getRoadPersonFlow()));
            cumulative.setTotalPersonFlow(sumNullable(cumulative.getTotalPersonFlow(), item.getTotalPersonFlow()));
        }
        return cumulative;
    }


    public DailyMetrics findMetricsByDate(LocalDate date) {
        HolidayCalendar calendar = configService.findHolidayByDate(date);
        if (calendar == null) return null;
        return dailyMetrics(calendar.getYear(), calendar.getHolidayType(), calendar.getDayIndex());
    }

    private Map<LocalDate, Map<String, BigDecimal>> loadPassengerByDate(int year) {
        Map<LocalDate, Map<String, BigDecimal>> result = new LinkedHashMap<>();
        List<HolidayPassengerFlow> rows = passengerFlowMapper.selectList(
                new LambdaQueryWrapper<HolidayPassengerFlow>().eq(HolidayPassengerFlow::getYear, year));
        for (HolidayPassengerFlow row : rows) {
            result.computeIfAbsent(row.getFlowDate(), key -> new LinkedHashMap<>())
                    .put(row.getTransportMode(), row.getPassengerCount());
        }
        return result;
    }

    private Map<LocalDate, Map<String, BigDecimal>> loadVehicleByDate(int year) {
        Map<LocalDate, Map<String, BigDecimal>> result = new LinkedHashMap<>();
        List<HolidayVehicleFlow> rows = vehicleFlowMapper.selectList(
                new LambdaQueryWrapper<HolidayVehicleFlow>().eq(HolidayVehicleFlow::getYear, year));
        for (HolidayVehicleFlow row : rows) {
            result.computeIfAbsent(row.getFlowDate(), key -> new LinkedHashMap<>())
                    .put(row.getRoadCategory(), row.getVehicleCount());
        }
        return result;
    }

    private Map<LocalDate, BigDecimal> loadComparisonBaseByDate(int year) {
        Map<LocalDate, BigDecimal> result = new LinkedHashMap<>();
        List<HolidayVehicleFlow> rows = vehicleFlowMapper.selectList(
                new LambdaQueryWrapper<HolidayVehicleFlow>()
                        .eq(HolidayVehicleFlow::getYear, year)
                        .eq(HolidayVehicleFlow::getRoadCategory, HolidayConstants.ROAD_NATIONAL_PROVINCIAL));
        for (HolidayVehicleFlow row : rows) {
            if (row.getComparisonBase() != null) result.put(row.getFlowDate(), row.getComparisonBase());
        }
        return result;
    }

    private BigDecimal totalPersonFlow(Map<String, BigDecimal> passenger, BigDecimal nonBusinessPersonFlow) {
        BigDecimal total = nonBusinessPersonFlow;
        total = sumNullable(total, passenger.get(HolidayConstants.MODE_ROAD));
        total = sumNullable(total, passenger.get(HolidayConstants.MODE_RAIL));
        total = sumNullable(total, passenger.get(HolidayConstants.MODE_CIVIL_AVIATION));
        total = sumNullable(total, passenger.get(HolidayConstants.MODE_WATER));
        return total;
    }

    private BigDecimal nationalProvincialRingRatio(int year, BigDecimal current,
                                                   BigDecimal previous, BigDecimal comparisonBase) {
        if (current == null) return null;
        if (HolidayConstants.supportsComparisonBase(year) && comparisonBase != null) {
            return ratio(current, comparisonBase);
        }
        return previous == null ? null : ratio(current, previous);
    }

    private BigDecimal ratio(BigDecimal current, BigDecimal base) {
        BigDecimal quotient = HolidayNumberUtils.divide(current, base);
        return quotient == null ? null : HolidayNumberUtils.normalize(quotient.subtract(BigDecimal.ONE));
    }

    private BigDecimal sumNullable(BigDecimal left, BigDecimal right) {
        return HolidayNumberUtils.sumNullable(left, right);
    }

    private String joinErrors(List<String> errors) {
        if (errors == null || errors.isEmpty()) return null;
        StringBuilder builder = new StringBuilder();
        int limit = Math.min(errors.size(), 200);
        for (int i = 0; i < limit; i++) {
            if (i > 0) builder.append('\n');
            builder.append(errors.get(i));
        }
        if (errors.size() > limit) {
            builder.append("\n... ").append(errors.size() - limit).append(" more");
        }
        return builder.toString();
    }

    @Data
    public static class DailyMetrics {
        private int year;
        private String holidayType;
        private int dayIndex;
        private LocalDate date;
        private BigDecimal rail;
        private BigDecimal civilAviation;
        private BigDecimal road;
        private BigDecimal water;
        private BigDecimal expressway;
        private BigDecimal nationalProvincial;
        private BigDecimal comparisonBase;
        private BigDecimal coefficient;
        private BigDecimal nonBusinessPersonFlow;
        private BigDecimal roadPersonFlow;
        private BigDecimal totalPersonFlow;
    }
}

 traffic-audit-server/src/main/java/com/trafficaudit/holiday/service/HolidayWorkbookService.java

New file
@@ -0,0 +1,880 @@
package com.trafficaudit.holiday.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.trafficaudit.holiday.HolidayConstants;
import com.trafficaudit.holiday.HolidayNumberUtils;
import com.trafficaudit.holiday.entity.HolidayCalendar;
import com.trafficaudit.holiday.entity.HolidayPassengerCoefficient;
import com.trafficaudit.holiday.entity.HolidayPassengerFlow;
import com.trafficaudit.holiday.entity.HolidayVehicleFlow;
import com.trafficaudit.holiday.mapper.HolidayPassengerCoefficientMapper;
import com.trafficaudit.holiday.mapper.HolidayPassengerFlowMapper;
import com.trafficaudit.holiday.mapper.HolidayVehicleFlowMapper;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.DataFormatter;
import org.apache.poi.ss.usermodel.FormulaEvaluator;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.usermodel.WorkbookFactory;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeParseException;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

@Slf4j
@Service
public class HolidayWorkbookService {

    private static final Map<String, String> PASSENGER_SHEET_MODE = new LinkedHashMap<>();
    private static final int FIRST_DATA_ROW_INDEX = 2;
    private static final int[] REFERENCE_YEARS = {2024, 2025, 2026};

    static {
        PASSENGER_SHEET_MODE.put("铁路", HolidayConstants.MODE_RAIL);
        PASSENGER_SHEET_MODE.put("民航", HolidayConstants.MODE_CIVIL_AVIATION);
        PASSENGER_SHEET_MODE.put("道路", HolidayConstants.MODE_ROAD);
        PASSENGER_SHEET_MODE.put("æ°´è·¯", HolidayConstants.MODE_WATER);
    }

    @Resource
    private HolidayConfigService configService;
    @Resource
    private HolidayPassengerFlowMapper passengerFlowMapper;
    @Resource
    private HolidayVehicleFlowMapper vehicleFlowMapper;
    @Resource
    private HolidayPassengerCoefficientMapper coefficientMapper;

    @Value("${holiday.reference-path:docs/专项统计/重要节假日/2026年十一数据.xlsx}")
    private String referencePath;

    public File resolveReferenceFile() {
        List<File> candidates = new ArrayList<>();
        File configured = new File(referencePath);
        candidates.add(configured);
        if (!configured.isAbsolute()) {
            candidates.add(new File(System.getProperty("user.dir"), referencePath));
            candidates.add(new File(System.getProperty("user.dir"), "../" + referencePath));
        }
        for (File candidate : candidates) {
            try {
                if (candidate.exists() && candidate.isFile()) {
                    return candidate.getCanonicalFile();
                }
            } catch (Exception ignored) {
                // Keep checking the remaining candidate paths.
            }
        }
        return configured;
    }

    public String referenceFileName() {
        return resolveReferenceFile().getName();
    }

    @Transactional
    public ImportSummary importWorkbook(MultipartFile file, int year, String holidayType, boolean allowHistoricalOverwrite) {
        if (file == null || file.isEmpty()) {
            throw new IllegalArgumentException("请选择要导入的 Excel æ–‡ä»¶");
        }
        List<HolidayCalendar> holidayDays = configService.findHolidayDays(year, holidayType);
        if (holidayDays.isEmpty()) {
            throw new IllegalArgumentException("所选年份和节假日尚未配置日期，请先在系统配置中维护节假日");
        }
        Map<Integer, LocalDate> dateByDay = new LinkedHashMap<>();
        for (HolidayCalendar day : holidayDays) {
            dateByDay.put(day.getDayIndex(), day.getHolidayDate());
        }

        if (!allowHistoricalOverwrite) {
            ImportSummary historicalSummary = detectHistoricalChanges(file, year, dateByDay);
            if (historicalSummary.isConfirmationRequired()) {
                return historicalSummary;
            }
        }

        ImportSummary summary = new ImportSummary();
        try (InputStream in = file.getInputStream(); Workbook workbook = WorkbookFactory.create(in)) {
            FormulaEvaluator evaluator = workbook.getCreationHelper().createFormulaEvaluator();
            importPassengerSheets(workbook, evaluator, year, dateByDay, summary);
            importVehicleSheets(workbook, evaluator, year, dateByDay, summary);
        } catch (Exception e) {
            throw new IllegalArgumentException("工作簿解析失败: " + e.getMessage(), e);
        }
        return summary;
    }

    private ImportSummary detectHistoricalChanges(MultipartFile file, int year, Map<Integer, LocalDate> dateByDay) {
        ImportSummary summary = new ImportSummary();
        try (InputStream in = file.getInputStream(); Workbook workbook = WorkbookFactory.create(in)) {
            FormulaEvaluator evaluator = workbook.getCreationHelper().createFormulaEvaluator();
            int latestDay = findLatestIncomingDay(workbook, evaluator, year, dateByDay);
            if (latestDay <= 1) {
                return summary;
            }
            Map<LocalDate, Map<String, BigDecimal>> existingPassenger = loadPassengerByDate(year);
            Map<LocalDate, Map<String, BigDecimal>> existingVehicle = loadVehicleByDate(year);
            detectPassengerHistory(workbook, evaluator, year, dateByDay, latestDay, existingPassenger, summary);
            detectVehicleHistory(workbook, evaluator, year, dateByDay, latestDay, existingVehicle, summary);
            if (!summary.getHistoricalChanges().isEmpty()) {
                summary.setConfirmationRequired(true);
            }
        } catch (Exception e) {
            throw new IllegalArgumentException("工作簿解析失败: " + e.getMessage(), e);
        }
        return summary;
    }

    private int findLatestIncomingDay(Workbook workbook, FormulaEvaluator evaluator, int year, Map<Integer, LocalDate> dateByDay) {
        int latest = 0;
        for (Integer dayIndex : dateByDay.keySet()) {
            if (hasPassengerValue(workbook, evaluator, year, dayIndex)
                    || hasVehicleValue(workbook, evaluator, year, dayIndex)) {
                latest = Math.max(latest, dayIndex);
            }
        }
        return latest;
    }

    private boolean hasPassengerValue(Workbook workbook, FormulaEvaluator evaluator, int year, int dayIndex) {
        for (Map.Entry<String, String> entry : PASSENGER_SHEET_MODE.entrySet()) {
            Sheet sheet = workbook.getSheet(entry.getKey());
            if (sheet == null) continue;
            Integer yearColumn = findYearColumn(sheet, evaluator, year, 2, 7);
            if (yearColumn == null) continue;
            Row row = sheet.getRow(FIRST_DATA_ROW_INDEX + dayIndex - 1);
            if (row == null) continue;
            BigDecimal value = numberValue(row.getCell(yearColumn), evaluator);
            if (value != null) return true;
        }
        return false;
    }

    private boolean hasVehicleValue(Workbook workbook, FormulaEvaluator evaluator, int year, int dayIndex) {
        Sheet expressway = workbook.getSheet("高速公路");
        if (expressway != null) {
            Integer yearColumn = findYearColumn(expressway, evaluator, year, 2, 7);
            if (yearColumn != null) {
                Row row = expressway.getRow(FIRST_DATA_ROW_INDEX + dayIndex - 1);
                if (row != null && numberValue(row.getCell(yearColumn), evaluator) != null) return true;
            }
        }
        Sheet nationalProvincial = workbook.getSheet("普通国省道");
        if (nationalProvincial != null) {
            Integer yearColumn = findYearColumn(nationalProvincial, evaluator, year, 3, 8);
            if (yearColumn != null) {
                Row row = nationalProvincial.getRow(FIRST_DATA_ROW_INDEX + dayIndex - 1);
                if (row != null && numberValue(row.getCell(yearColumn), evaluator) != null) return true;
            }
        }
        return false;
    }

    private void detectPassengerHistory(Workbook workbook, FormulaEvaluator evaluator, int year,
                                       Map<Integer, LocalDate> dateByDay, int latestDay,
                                       Map<LocalDate, Map<String, BigDecimal>> existing,
                                       ImportSummary summary) {
        for (Map.Entry<String, String> entry : PASSENGER_SHEET_MODE.entrySet()) {
            Sheet sheet = workbook.getSheet(entry.getKey());
            if (sheet == null) continue;
            Integer yearColumn = findYearColumn(sheet, evaluator, year, 2, 7);
            if (yearColumn == null) continue;
            for (Map.Entry<Integer, LocalDate> day : dateByDay.entrySet()) {
                if (day.getKey() >= latestDay) continue;
                Row row = sheet.getRow(FIRST_DATA_ROW_INDEX + day.getKey() - 1);
                if (row == null) continue;
                BigDecimal incoming = numberValue(row.getCell(yearColumn), evaluator);
                if (incoming == null) continue;
                Map<String, BigDecimal> existingDay = existing.get(day.getValue());
                BigDecimal oldValue = existingDay == null ? null : existingDay.get(entry.getValue());
                if (oldValue != null && !sameValue(oldValue, incoming)) {
                    summary.addHistoricalChange("第" + day.getKey() + "日 " + day.getValue() + " "
                            + entry.getKey() + "：原值 " + formatChangeValue(oldValue) + "，导入值 " + formatChangeValue(incoming));
                }
            }
        }
    }

    private void detectVehicleHistory(Workbook workbook, FormulaEvaluator evaluator, int year,
                                      Map<Integer, LocalDate> dateByDay, int latestDay,
                                      Map<LocalDate, Map<String, BigDecimal>> existing,
                                      ImportSummary summary) {
        detectVehicleSheetHistory(workbook, evaluator, year, dateByDay, latestDay, existing, summary,
                "高速公路", HolidayConstants.ROAD_EXPRESSWAY, 2, 7);
        detectVehicleSheetHistory(workbook, evaluator, year, dateByDay, latestDay, existing, summary,
                "普通国省道", HolidayConstants.ROAD_NATIONAL_PROVINCIAL, 3, 8);
        detectComparisonBaseHistory(workbook, evaluator, year, dateByDay, latestDay, existing, summary);
    }

    private void detectVehicleSheetHistory(Workbook workbook, FormulaEvaluator evaluator, int year,
                                           Map<Integer, LocalDate> dateByDay, int latestDay,
                                           Map<LocalDate, Map<String, BigDecimal>> existing,
                                           ImportSummary summary, String sheetName, String roadCategory,
                                           int startColumn, int endColumn) {
        Sheet sheet = workbook.getSheet(sheetName);
        if (sheet == null) return;
        Integer yearColumn = findYearColumn(sheet, evaluator, year, startColumn, endColumn);
        if (yearColumn == null) return;
        for (Map.Entry<Integer, LocalDate> day : dateByDay.entrySet()) {
            if (day.getKey() >= latestDay) continue;
            Row row = sheet.getRow(FIRST_DATA_ROW_INDEX + day.getKey() - 1);
            if (row == null) continue;
            BigDecimal incoming = numberValue(row.getCell(yearColumn), evaluator);
            if (incoming == null) continue;
            Map<String, BigDecimal> existingDay = existing.get(day.getValue());
            BigDecimal oldValue = existingDay == null ? null : existingDay.get(roadCategory);
            if (oldValue != null && !sameValue(oldValue, incoming)) {
                summary.addHistoricalChange("第" + day.getKey() + "日 " + day.getValue() + " "
                        + sheetName + "：原值 " + formatChangeValue(oldValue) + "，导入值 " + formatChangeValue(incoming));
            }
        }
    }

    private void detectComparisonBaseHistory(Workbook workbook, FormulaEvaluator evaluator, int year,
                                             Map<Integer, LocalDate> dateByDay, int latestDay,
                                             Map<LocalDate, Map<String, BigDecimal>> existingVehicle,
                                             ImportSummary summary) {
        if (!HolidayConstants.supportsComparisonBase(year)) return;
        Sheet sheet = workbook.getSheet("普通国省道");
        if (sheet == null) return;
        Map<LocalDate, BigDecimal> existingBase = loadComparisonBaseByDate(year);
        for (Map.Entry<Integer, LocalDate> day : dateByDay.entrySet()) {
            if (day.getKey() >= latestDay) continue;
            Map<String, BigDecimal> existingDay = existingVehicle.get(day.getValue());
            if (existingDay == null || existingDay.get(HolidayConstants.ROAD_NATIONAL_PROVINCIAL) == null) continue;
            Row row = sheet.getRow(FIRST_DATA_ROW_INDEX + day.getKey() - 1);
            if (row == null) continue;
            BigDecimal incoming;
            try {
                incoming = numberValue(row.getCell(2), evaluator);
            } catch (Exception e) {
                summary.addError("普通国省道 ç¬¬" + (row.getRowNum() + 1) + "行环比基期：" + e.getMessage());
                continue;
            }
            BigDecimal oldValue = existingBase.get(day.getValue());
            if (!sameNullableValue(oldValue, incoming)) {
                summary.addHistoricalChange("第" + day.getKey() + "日 " + day.getValue() + " æ™®é€šå›½çœé“环比基期：原值 "
                        + nullableChangeValue(oldValue) + "，导入值 " + nullableChangeValue(incoming));
            }
        }
    }

        Map<LocalDate, Map<String, BigDecimal>> result = new LinkedHashMap<>();
    private Map<LocalDate, Map<String, BigDecimal>> loadPassengerByDate(int year) {
        List<HolidayPassengerFlow> rows = passengerFlowMapper.selectList(
                new LambdaQueryWrapper<HolidayPassengerFlow>().eq(HolidayPassengerFlow::getYear, year));
        for (HolidayPassengerFlow row : rows) {
            result.computeIfAbsent(row.getFlowDate(), key -> new LinkedHashMap<>())
                    .put(row.getTransportMode(), row.getPassengerCount());
        }
        return result;
    }

    private Map<LocalDate, Map<String, BigDecimal>> loadVehicleByDate(int year) {
        Map<LocalDate, Map<String, BigDecimal>> result = new LinkedHashMap<>();
        List<HolidayVehicleFlow> rows = vehicleFlowMapper.selectList(
                new LambdaQueryWrapper<HolidayVehicleFlow>().eq(HolidayVehicleFlow::getYear, year));
        for (HolidayVehicleFlow row : rows) {
            result.computeIfAbsent(row.getFlowDate(), key -> new LinkedHashMap<>())
                    .put(row.getRoadCategory(), row.getVehicleCount());
        }
        return result;
    }

    private Map<LocalDate, BigDecimal> loadComparisonBaseByDate(int year) {
        Map<LocalDate, BigDecimal> result = new LinkedHashMap<>();
        List<HolidayVehicleFlow> rows = vehicleFlowMapper.selectList(
                new LambdaQueryWrapper<HolidayVehicleFlow>()
                        .eq(HolidayVehicleFlow::getYear, year)
                        .eq(HolidayVehicleFlow::getRoadCategory, HolidayConstants.ROAD_NATIONAL_PROVINCIAL));
        for (HolidayVehicleFlow row : rows) result.put(row.getFlowDate(), row.getComparisonBase());
        return result;
    }

    private boolean sameValue(BigDecimal left, BigDecimal right) {
        return HolidayNumberUtils.sameValue(left, right);
    }

    private boolean sameNullableValue(BigDecimal left, BigDecimal right) {
        if (left == null || right == null) return left == right;
        return sameValue(left, right);
    }

    private String nullableChangeValue(BigDecimal value) {
        return value == null ? "空" : formatChangeValue(value);
    }

    private String formatChangeValue(BigDecimal value) {
        return HolidayNumberUtils.changeText(value);
    }

    @Transactional
    public void seedReferenceDataIfNeeded() {
        File reference = resolveReferenceFile();
        if (!reference.exists() || !reference.isFile()) {
            log.warn("Holiday reference workbook not found: {}", reference.getAbsolutePath());
            return;
        }
        try (InputStream in = new FileInputStream(reference); Workbook workbook = WorkbookFactory.create(in)) {
            FormulaEvaluator evaluator = workbook.getCreationHelper().createFormulaEvaluator();
            seedNationalDayCalendar();
            for (int year : REFERENCE_YEARS) {
                if (passengerFlowMapper.selectCount(new LambdaQueryWrapper<HolidayPassengerFlow>()
                        .eq(HolidayPassengerFlow::getYear, year)) == 0) {
                    seedPassengerYear(workbook, evaluator, year);
                }
                if (vehicleFlowMapper.selectCount(new LambdaQueryWrapper<HolidayVehicleFlow>()
                        .eq(HolidayVehicleFlow::getYear, year)) == 0) {
                    seedVehicleYear(workbook, evaluator, year);
                }
                if (coefficientMapper.selectCount(new LambdaQueryWrapper<HolidayPassengerCoefficient>()
                        .eq(HolidayPassengerCoefficient::getYear, year)) == 0) {
                    seedCoefficientYear(workbook, evaluator, year);
                }
            }
        } catch (Exception e) {
            log.error("Failed to seed holiday reference data", e);
        }
    }

    public byte[] exportWorkbook(int year, String holidayType) {
        File reference = resolveReferenceFile();
        if (!reference.exists() || !reference.isFile()) {
            throw new IllegalArgumentException("节假日模板文件不存在: " + reference.getAbsolutePath());
        }
        try (InputStream in = new FileInputStream(reference); XSSFWorkbook workbook = new XSSFWorkbook(in)) {
            FormulaEvaluator evaluator = workbook.getCreationHelper().createFormulaEvaluator();
            fillPassengerSheets(workbook, evaluator, year, holidayType);
            fillVehicleSheets(workbook, evaluator, year, holidayType);
            fillCoefficients(workbook, evaluator, year, holidayType);
            workbook.setForceFormulaRecalculation(true);
            try {
                evaluator.evaluateAll();
            } catch (Exception e) {
                log.warn("Workbook formula recalculation did not complete; Excel will recalculate on open", e);
            }
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            workbook.write(out);
            return out.toByteArray();
        } catch (Exception e) {
            throw new IllegalArgumentException("节假日数据导出失败: " + e.getMessage(), e);
        }
    }

    private void importPassengerSheets(Workbook workbook, FormulaEvaluator evaluator, int year,
                                       Map<Integer, LocalDate> dateByDay, ImportSummary summary) {
        for (Map.Entry<String, String> entry : PASSENGER_SHEET_MODE.entrySet()) {
            Sheet sheet = workbook.getSheet(entry.getKey());
            if (sheet == null) {
                summary.addError(entry.getKey() + "：找不到工作表");
                continue;
            }
            Integer yearColumn = findYearColumn(sheet, evaluator, year, 2, 7);
            if (yearColumn == null) {
                summary.addError(entry.getKey() + "：找不到 " + year + " å¹´æ•°æ®åˆ—");
                continue;
            }
            for (Map.Entry<Integer, LocalDate> day : dateByDay.entrySet()) {
                Row row = sheet.getRow(FIRST_DATA_ROW_INDEX + day.getKey() - 1);
                if (row == null) {
                    summary.addError(entry.getKey() + " ç¬¬" + day.getKey() + "日：工作表缺少该行");
                    continue;
                }
                Integer rowDay = parseDayIndex(row.getCell(0), evaluator);
                if (rowDay == null || !rowDay.equals(day.getKey())) {
                    summary.addError(entry.getKey() + " ç¬¬" + (row.getRowNum() + 1) + "行：第几日与节假日配置不一致");
                    continue;
                }
                BigDecimal value;
                try {
                    value = numberValue(row.getCell(yearColumn), evaluator);
                } catch (Exception e) {
                    summary.addError(entry.getKey() + " ç¬¬" + (row.getRowNum() + 1) + "行：" + e.getMessage());
                    continue;
                }
                if (value == null) {
                    summary.incrementSkipped();
                    continue;
                }
                upsertPassenger(year, day.getValue(), entry.getValue(), value);
                summary.incrementPassenger();
            }
        }
    }

    private void importVehicleSheets(Workbook workbook, FormulaEvaluator evaluator, int year,
                                     Map<Integer, LocalDate> dateByDay, ImportSummary summary) {
        importVehicleSheet(workbook, evaluator, year, dateByDay, summary,
                "高速公路", HolidayConstants.ROAD_EXPRESSWAY, HolidayConstants.VEHICLE_SMALL_PASSENGER, 2, 7, null);
        importVehicleSheet(workbook, evaluator, year, dateByDay, summary,
                "普通国省道", HolidayConstants.ROAD_NATIONAL_PROVINCIAL, HolidayConstants.VEHICLE_MEDIUM_SMALL_PASSENGER, 3, 8,
                HolidayConstants.supportsComparisonBase(year) ? 2 : null);
    }

    private void importVehicleSheet(Workbook workbook, FormulaEvaluator evaluator, int year,
                                    Map<Integer, LocalDate> dateByDay, ImportSummary summary,
                                    String sheetName, String roadCategory, String vehicleType,
                                    int startColumn, int endColumn, Integer comparisonBaseColumn) {
        Sheet sheet = workbook.getSheet(sheetName);
        if (sheet == null) {
            summary.addError(sheetName + "：找不到工作表");
            return;
        }
        Integer yearColumn = findYearColumn(sheet, evaluator, year, startColumn, endColumn);
        if (yearColumn == null) {
            summary.addError(sheetName + "：找不到 " + year + " å¹´æ•°æ®åˆ—");
            return;
        }
        for (Map.Entry<Integer, LocalDate> day : dateByDay.entrySet()) {
            Row row = sheet.getRow(FIRST_DATA_ROW_INDEX + day.getKey() - 1);
            if (row == null) {
                summary.addError(sheetName + " ç¬¬" + day.getKey() + "日：工作表缺少该行");
                continue;
            }
            Integer rowDay = parseDayIndex(row.getCell(0), evaluator);
            if (rowDay == null || !rowDay.equals(day.getKey())) {
                summary.addError(sheetName + " ç¬¬" + (row.getRowNum() + 1) + "行：第几日与节假日配置不一致");
                continue;
            }
            BigDecimal value;
            try {
                value = numberValue(row.getCell(yearColumn), evaluator);
            } catch (Exception e) {
                summary.addError(sheetName + " ç¬¬" + (row.getRowNum() + 1) + "行：" + e.getMessage());
                continue;
            }
            if (value == null) {
                summary.incrementSkipped();
                continue;
            }
            BigDecimal comparisonBase = null;
            if (comparisonBaseColumn != null) {
                try {
                    comparisonBase = numberValue(row.getCell(comparisonBaseColumn), evaluator);
                } catch (Exception e) {
                    summary.addError(sheetName + " ç¬¬" + (row.getRowNum() + 1) + "行环比基期：" + e.getMessage());
                    continue;
                }
            }
            upsertVehicle(year, day.getValue(), roadCategory, vehicleType, value, comparisonBase);
            summary.incrementVehicle();
        }
    }

    private void fillPassengerSheets(XSSFWorkbook workbook, FormulaEvaluator evaluator, int selectedYear, String holidayType) {
        for (Map.Entry<String, String> entry : PASSENGER_SHEET_MODE.entrySet()) {
            Sheet sheet = workbook.getSheet(entry.getKey());
            if (sheet == null) continue;
            for (int year : REFERENCE_YEARS) {
                Integer yearColumn = findYearColumn(sheet, evaluator, year, 2, 7);
                if (yearColumn == null) continue;
                Map<Integer, LocalDate> dayDates = dayDates(year, holidayType);
                Map<LocalDate, BigDecimal> values = loadPassengerValues(year, entry.getValue());
                for (Map.Entry<Integer, LocalDate> day : dayDates.entrySet()) {
                    if (!values.containsKey(day.getValue())) continue;
                    setNumeric(sheet, FIRST_DATA_ROW_INDEX + day.getKey() - 1, yearColumn, values.get(day.getValue()));
                }
            }
        }
    }

    private void fillVehicleSheets(XSSFWorkbook workbook, FormulaEvaluator evaluator, int selectedYear, String holidayType) {
        fillVehicleSheet(workbook, evaluator, "高速公路", HolidayConstants.ROAD_EXPRESSWAY, 2, 7, holidayType, null);
        fillVehicleSheet(workbook, evaluator, "普通国省道", HolidayConstants.ROAD_NATIONAL_PROVINCIAL, 3, 8, holidayType,
                HolidayConstants.supportsComparisonBase(selectedYear) ? 2 : null);
    }

    private void fillVehicleSheet(XSSFWorkbook workbook, FormulaEvaluator evaluator, String sheetName,
                                  String roadCategory, int startColumn, int endColumn, String holidayType,
                                  Integer comparisonBaseColumn) {
        Sheet sheet = workbook.getSheet(sheetName);
        if (sheet == null) return;
        for (int year : REFERENCE_YEARS) {
            Integer yearColumn = findYearColumn(sheet, evaluator, year, startColumn, endColumn);
            if (yearColumn == null) continue;
            Map<Integer, LocalDate> dayDates = dayDates(year, holidayType);
            Map<LocalDate, BigDecimal> values = loadVehicleValues(year, roadCategory);
            for (Map.Entry<Integer, LocalDate> day : dayDates.entrySet()) {
                if (!values.containsKey(day.getValue())) continue;
                setNumeric(sheet, FIRST_DATA_ROW_INDEX + day.getKey() - 1, yearColumn, values.get(day.getValue()));
            }
            if (comparisonBaseColumn != null && HolidayConstants.supportsComparisonBase(year)) {
                Map<LocalDate, BigDecimal> bases = loadComparisonBaseValues(year);
                for (Map.Entry<Integer, LocalDate> day : dayDates.entrySet()) {
                    if (!bases.containsKey(day.getValue())) continue;
                    setNumeric(sheet, FIRST_DATA_ROW_INDEX + day.getKey() - 1, comparisonBaseColumn, bases.get(day.getValue()));
                }
                for (Map.Entry<Integer, LocalDate> day : dayDates.entrySet()) {
                    if (!bases.containsKey(day.getValue())) continue;
                    int rowIndex = FIRST_DATA_ROW_INDEX + day.getKey() - 1;
                    int excelRow = rowIndex + 1;
                    setFormula(sheet, rowIndex, 4, "=(D" + excelRow + "-C" + excelRow + ")/C" + excelRow);
                }
            }
        }
    }

    private void fillCoefficients(XSSFWorkbook workbook, FormulaEvaluator evaluator, int selectedYear, String holidayType) {
        fillCoefficientSheet(workbook, evaluator, "高速公路", 8, 10, holidayType);
        fillCoefficientSheet(workbook, evaluator, "普通国省道", 9, 11, holidayType);
    }

    private void fillCoefficientSheet(XSSFWorkbook workbook, FormulaEvaluator evaluator, String sheetName,
                                      int startColumn, int endColumn, String holidayType) {
        Sheet sheet = workbook.getSheet(sheetName);
        if (sheet == null) return;
        for (int year : REFERENCE_YEARS) {
            Integer yearColumn = findYearColumn(sheet, evaluator, year, startColumn, endColumn);
            if (yearColumn == null) continue;
            BigDecimal coefficient = configService.coefficientOf(year, HolidayConstants.CATEGORY_HOLIDAY);
            if (coefficient == null) continue;
            Map<Integer, LocalDate> dayDates = dayDates(year, holidayType);
            for (Integer dayIndex : dayDates.keySet()) {
                setNumeric(sheet, FIRST_DATA_ROW_INDEX + dayIndex - 1, yearColumn, coefficient);
            }
        }
    }

    private void seedNationalDayCalendar() {
        // Calendar is admin-managed after the first bootstrap. Re-adding missing day indexes on
        // every start would resurrect days the admin deleted, so only seed a fresh table.
        if (!configService.listHolidays(null, null).isEmpty()) {
            return;
        }
        int[] lengths = {7, 8, 8};
        for (int i = 0; i < REFERENCE_YEARS.length; i++) {
            int year = REFERENCE_YEARS[i];
            List<HolidayCalendar> existing = configService.findHolidayDays(year, HolidayConstants.TYPE_NATIONAL_DAY);
            Map<Integer, HolidayCalendar> byDay = new LinkedHashMap<>();
            for (HolidayCalendar row : existing) {
                byDay.put(row.getDayIndex(), row);
            }
            for (int day = 1; day <= lengths[i]; day++) {
                if (byDay.containsKey(day)) continue;
                HolidayCalendar calendar = new HolidayCalendar();
                calendar.setYear(year);
                calendar.setHolidayType(HolidayConstants.TYPE_NATIONAL_DAY);
                calendar.setHolidayDate(LocalDate.of(year, 10, day));
                calendar.setDayIndex(day);
                calendar.setCreatedAt(LocalDateTime.now());
                calendar.setUpdatedAt(LocalDateTime.now());
                configService.saveHoliday(toMap(calendar));
            }
        }
    }

    private void seedPassengerYear(Workbook workbook, FormulaEvaluator evaluator, int year) {
        Map<Integer, LocalDate> dayDates = dayDates(year, HolidayConstants.TYPE_NATIONAL_DAY);
        if (dayDates.isEmpty()) return;
        for (Map.Entry<String, String> entry : PASSENGER_SHEET_MODE.entrySet()) {
            Sheet sheet = workbook.getSheet(entry.getKey());
            if (sheet == null) continue;
            Integer yearColumn = findYearColumn(sheet, evaluator, year, 2, 7);
            if (yearColumn == null) continue;
            for (Map.Entry<Integer, LocalDate> day : dayDates.entrySet()) {
                Row row = sheet.getRow(FIRST_DATA_ROW_INDEX + day.getKey() - 1);
                if (row == null) continue;
                BigDecimal value = numberValue(row.getCell(yearColumn), evaluator);
                if (value != null) {
                    upsertPassenger(year, day.getValue(), entry.getValue(), value);
                }
            }
        }
    }

    private void seedVehicleYear(Workbook workbook, FormulaEvaluator evaluator, int year) {
        Map<Integer, LocalDate> dayDates = dayDates(year, HolidayConstants.TYPE_NATIONAL_DAY);
        if (dayDates.isEmpty()) return;
        seedVehicleSheet(workbook, evaluator, year, dayDates, "高速公路",
                HolidayConstants.ROAD_EXPRESSWAY, HolidayConstants.VEHICLE_SMALL_PASSENGER, 2, 7);
        seedVehicleSheet(workbook, evaluator, year, dayDates, "普通国省道",
                HolidayConstants.ROAD_NATIONAL_PROVINCIAL, HolidayConstants.VEHICLE_MEDIUM_SMALL_PASSENGER, 3, 8);
    }

    private void seedVehicleSheet(Workbook workbook, FormulaEvaluator evaluator, int year,
                                  Map<Integer, LocalDate> dayDates, String sheetName,
                                  String roadCategory, String vehicleType, int startColumn, int endColumn) {
        Sheet sheet = workbook.getSheet(sheetName);
        if (sheet == null) return;
        Integer yearColumn = findYearColumn(sheet, evaluator, year, startColumn, endColumn);
        if (yearColumn == null) return;
        for (Map.Entry<Integer, LocalDate> day : dayDates.entrySet()) {
            Row row = sheet.getRow(FIRST_DATA_ROW_INDEX + day.getKey() - 1);
            if (row == null) continue;
            BigDecimal value = numberValue(row.getCell(yearColumn), evaluator);
            if (value != null) {
                upsertVehicle(year, day.getValue(), roadCategory, vehicleType, value, null);
            }
        }
    }

    private void seedCoefficientYear(Workbook workbook, FormulaEvaluator evaluator, int year) {
        List<BigDecimal> values = new ArrayList<>();
        collectCoefficientValues(workbook, evaluator, "高速公路", year, 8, 10, values);
        collectCoefficientValues(workbook, evaluator, "普通国省道", year, 9, 11, values);
        if (values.isEmpty()) return;
        BigDecimal sum = BigDecimal.ZERO;
        for (BigDecimal value : values) {
            sum = HolidayNumberUtils.normalize(sum.add(value));
        }
        BigDecimal coefficient = HolidayNumberUtils.divide(sum, BigDecimal.valueOf(values.size()));
        upsertCoefficient(year, HolidayConstants.CATEGORY_HOLIDAY, coefficient);
        upsertCoefficient(year, HolidayConstants.CATEGORY_NON_HOLIDAY, coefficient);
    }

    private void collectCoefficientValues(Workbook workbook, FormulaEvaluator evaluator, String sheetName,
                                          int year, int startColumn, int endColumn, List<BigDecimal> values) {
        Sheet sheet = workbook.getSheet(sheetName);
        if (sheet == null) return;
        Integer yearColumn = findYearColumn(sheet, evaluator, year, startColumn, endColumn);
        if (yearColumn == null) return;
        for (int rowIndex = FIRST_DATA_ROW_INDEX; rowIndex < FIRST_DATA_ROW_INDEX + 10; rowIndex++) {
            Row row = sheet.getRow(rowIndex);
            if (row == null) continue;
            try {
                BigDecimal value = numberValue(row.getCell(yearColumn), evaluator);
                if (value != null && value.compareTo(BigDecimal.ZERO) > 0) values.add(value);
            } catch (Exception ignored) {
                // Skip cells that are not numeric coefficients.
            }
        }
    }

    private Map<Integer, LocalDate> dayDates(int year, String holidayType) {
        Map<Integer, LocalDate> result = new LinkedHashMap<>();
        for (HolidayCalendar row : configService.findHolidayDays(year, holidayType)) {
            result.put(row.getDayIndex(), row.getHolidayDate());
        }
        return result;
    }

    private Map<LocalDate, BigDecimal> loadPassengerValues(int year, String transportMode) {
        Map<LocalDate, BigDecimal> result = new LinkedHashMap<>();
        List<HolidayPassengerFlow> rows = passengerFlowMapper.selectList(
                new LambdaQueryWrapper<HolidayPassengerFlow>()
                        .eq(HolidayPassengerFlow::getYear, year)
                        .eq(HolidayPassengerFlow::getTransportMode, transportMode));
        for (HolidayPassengerFlow row : rows) result.put(row.getFlowDate(), row.getPassengerCount());
        return result;
    }

    private Map<LocalDate, BigDecimal> loadVehicleValues(int year, String roadCategory) {
        Map<LocalDate, BigDecimal> result = new LinkedHashMap<>();
        List<HolidayVehicleFlow> rows = vehicleFlowMapper.selectList(
                new LambdaQueryWrapper<HolidayVehicleFlow>()
                        .eq(HolidayVehicleFlow::getYear, year)
                        .eq(HolidayVehicleFlow::getRoadCategory, roadCategory));
        for (HolidayVehicleFlow row : rows) result.put(row.getFlowDate(), row.getVehicleCount());
        return result;
    }

    private Map<LocalDate, BigDecimal> loadComparisonBaseValues(int year) {
        Map<LocalDate, BigDecimal> result = new LinkedHashMap<>();
        List<HolidayVehicleFlow> rows = vehicleFlowMapper.selectList(
                new LambdaQueryWrapper<HolidayVehicleFlow>()
                        .eq(HolidayVehicleFlow::getYear, year)
                        .eq(HolidayVehicleFlow::getRoadCategory, HolidayConstants.ROAD_NATIONAL_PROVINCIAL));
        for (HolidayVehicleFlow row : rows) {
            if (row.getComparisonBase() != null) result.put(row.getFlowDate(), row.getComparisonBase());
        }
        return result;
    }

    private void upsertPassenger(int year, LocalDate date, String mode, BigDecimal value) {
        HolidayPassengerFlow existing = passengerFlowMapper.selectOne(new LambdaQueryWrapper<HolidayPassengerFlow>()
                .eq(HolidayPassengerFlow::getYear, year)
                .eq(HolidayPassengerFlow::getFlowDate, date)
                .eq(HolidayPassengerFlow::getTransportMode, mode)
                .last("limit 1"));
        if (existing == null) {
            existing = new HolidayPassengerFlow();
            existing.setYear(year);
            existing.setFlowDate(date);
            existing.setTransportMode(mode);
            existing.setPassengerCount(value);
            existing.setCreatedAt(LocalDateTime.now());
            existing.setUpdatedAt(LocalDateTime.now());
            passengerFlowMapper.insert(existing);
        } else {
            existing.setPassengerCount(value);
            existing.setUpdatedAt(LocalDateTime.now());
            passengerFlowMapper.updateById(existing);
        }
    }

    private void upsertVehicle(int year, LocalDate date, String roadCategory, String vehicleType,
                               BigDecimal value, BigDecimal comparisonBase) {
        HolidayVehicleFlow existing = vehicleFlowMapper.selectOne(new LambdaQueryWrapper<HolidayVehicleFlow>()
                .eq(HolidayVehicleFlow::getYear, year)
                .eq(HolidayVehicleFlow::getFlowDate, date)
                .eq(HolidayVehicleFlow::getRoadCategory, roadCategory)
                .eq(HolidayVehicleFlow::getVehicleType, vehicleType)
                .last("limit 1"));
        if (existing == null) {
            existing = new HolidayVehicleFlow();
            existing.setYear(year);
            existing.setFlowDate(date);
            existing.setRoadCategory(roadCategory);
            existing.setVehicleType(vehicleType);
            existing.setVehicleCount(value);
            existing.setComparisonBase(comparisonBase);
            existing.setCreatedAt(LocalDateTime.now());
            existing.setUpdatedAt(LocalDateTime.now());
            vehicleFlowMapper.insert(existing);
        } else {
            existing.setVehicleCount(value);
            existing.setComparisonBase(comparisonBase);
            existing.setUpdatedAt(LocalDateTime.now());
            vehicleFlowMapper.updateById(existing);
        }
    }

    private void upsertCoefficient(int year, String dateCategory, BigDecimal value) {
        HolidayPassengerCoefficient existing = coefficientMapper.selectOne(
                new LambdaQueryWrapper<HolidayPassengerCoefficient>()
                        .eq(HolidayPassengerCoefficient::getYear, year)
                        .eq(HolidayPassengerCoefficient::getDateCategory, dateCategory)
                        .last("limit 1"));
        if (existing == null) {
            existing = new HolidayPassengerCoefficient();
            existing.setYear(year);
            existing.setDateCategory(dateCategory);
            existing.setCoefficient(value);
            existing.setCreatedAt(LocalDateTime.now());
            existing.setUpdatedAt(LocalDateTime.now());
            coefficientMapper.insert(existing);
        } else {
            existing.setCoefficient(value);
            existing.setUpdatedAt(LocalDateTime.now());
            coefficientMapper.updateById(existing);
        }
    }

    private Integer findYearColumn(Sheet sheet, FormulaEvaluator evaluator, int year, int startColumn, int endColumn) {
        Row header = sheet.getRow(1);
        if (header == null) return null;
        String wanted = year + "å¹´";
        DataFormatter formatter = new DataFormatter();
        for (int column = startColumn; column <= endColumn; column++) {
            Cell cell = header.getCell(column);
            if (cell == null) continue;
            String text = formatter.formatCellValue(cell, evaluator).replace("\n", "").trim();
            if (wanted.equals(text) || text.startsWith(wanted + "累计")) return column;
        }
        return null;
    }

    private Integer parseDayIndex(Cell cell, FormulaEvaluator evaluator) {
        if (cell == null) return null;
        DataFormatter formatter = new DataFormatter();
        String text = formatter.formatCellValue(cell, evaluator).trim();
        java.util.regex.Matcher matcher = java.util.regex.Pattern.compile("第\\s*(\\d+)\\s*日").matcher(text);
        return matcher.find() ? Integer.valueOf(matcher.group(1)) : null;
    }

    private BigDecimal numberValue(Cell cell, FormulaEvaluator evaluator) {
        if (cell == null) return null;
        CellType type = cell.getCellType();
        if (type == CellType.FORMULA) {
            type = evaluator.evaluateFormulaCell(cell);
        }
        if (type == CellType.BLANK) return null;
        if (type == CellType.NUMERIC) return HolidayNumberUtils.excelValue(cell.getNumericCellValue());
        if (type == CellType.STRING) {
            String text = cell.getStringCellValue().trim().replace(",", "");
            if (text.isEmpty() || "-".equals(text) || "—".equals(text)) return null;
            try {
                return HolidayNumberUtils.decimalValue(text);
            } catch (NumberFormatException e) {
                throw new IllegalArgumentException("单元格不是有效数字: " + text);
            }
        }
        if (type == CellType.BOOLEAN) throw new IllegalArgumentException("单元格不能是布尔值");
        throw new IllegalArgumentException("单元格不是有效数字");
    }

    private void setNumeric(Sheet sheet, int rowIndex, int columnIndex, BigDecimal value) {
        if (value == null) return;
        Row row = sheet.getRow(rowIndex);
        if (row == null) row = sheet.createRow(rowIndex);
        Cell cell = row.getCell(columnIndex);
        if (cell == null) cell = row.createCell(columnIndex);
        cell.setCellValue(value.doubleValue());
    }

    private void setFormula(Sheet sheet, int rowIndex, int columnIndex, String formula) {
        Row row = sheet.getRow(rowIndex);
        if (row == null) row = sheet.createRow(rowIndex);
        Cell cell = row.getCell(columnIndex);
        if (cell == null) cell = row.createCell(columnIndex);
        cell.setCellFormula(formula);
    }

    private Map<String, Object> toMap(HolidayCalendar calendar) {
        Map<String, Object> params = new LinkedHashMap<>();
        params.put("year", calendar.getYear());
        params.put("holidayType", calendar.getHolidayType());
        params.put("holidayDate", calendar.getHolidayDate().toString());
        params.put("dayIndex", calendar.getDayIndex());
        return params;
    }

    @Data
    public static class ImportSummary {
        private int passengerRows;
        private int vehicleRows;
        private int skippedRows;
        private boolean confirmationRequired;
        private final List<String> errors = new ArrayList<>();
        private final List<String> historicalChanges = new ArrayList<>();

        public void incrementPassenger() {
            passengerRows++;
        }

        public void incrementVehicle() {
            vehicleRows++;
        }

        public void incrementSkipped() {
            skippedRows++;
        }

        public void addError(String message) {
            errors.add(message);
        }

        public void addHistoricalChange(String message) {
            if (historicalChanges.size() < 200) {
                historicalChanges.add(message);
            }
        }

        public int getSuccessRows() {
            return passengerRows + vehicleRows;
        }

        public int getFailRows() {
            return errors.size();
        }
    }
}

 traffic-audit-server/src/main/java/com/trafficaudit/reportexport/calc/FreightCalc.java

@@ -147,14 +147,15 @@
        Double aboveFreight = null;
        Map<Integer, Double> h2032Buckets = h2032TonByCityMonth.get(city);
        if (h2032Buckets != null) {
            double ton;
            if (cumulative) {
                ton = 0.0;
                double ton = 0.0;
                for (int m = 1; m <= month; m++) ton += h2032Buckets.getOrDefault(m, 0.0);
                aboveFreight = ton / 10000.0;
            } else {
                ton = h2032Buckets.getOrDefault(month, 0.0);
                // å½“月无规上记录 -> ç•™ç©ºï¼ˆä¸å†å†™ 0）；有记录（含真实 0 å€¼ï¼‰æ‰å†™æ•°
                Double ton = h2032Buckets.get(month);
                aboveFreight = ton == null ? null : ton / 10000.0;
            }
            aboveFreight = ton / 10000.0;
        }

        FreightTurnoverImport ft = ftMap.get(city);

 traffic-audit-web/src/main.js

@@ -11,6 +11,11 @@

// å…¨å±€ç™»å‡ºï¼šæ¸…除登录态并回登录页（各页面侧边栏「退出登录」菜单共用）
Vue.mixin({
  computed: {
    operatorIsAdmin() {
      return sessionStorage.getItem('username') === 'admin'
    }
  },
  methods: {
    // el-menu åŒè·¯ç”±å¯¼èˆªï¼ˆNavigationDuplicated）时 Element UI ä¼šæŠŠé«˜äº®å›žæ»šä¸ºç‚¹å‡»å‰æ—§å€¼ï¼›
    // ç‚¹å‡»åŽå»¶è¿Ÿä¸€ä¸ªå®ä»»åŠ¡å¼ºåˆ¶çº æ­£ï¼ˆå®ä»»åŠ¡æ™šäºŽ push çš„微任务回调，保证最终高亮正确）。

 traffic-audit-web/src/router/index.js

@@ -14,7 +14,9 @@
    { path: '/audit', name: 'AuditResult', component: () => import('@/views/AuditResult.vue') },
    { path: '/report', name: 'ReportExport', component: () => import('@/views/ReportExport.vue') },
    { path: '/rules', name: 'RuleManage', component: () => import('@/views/RuleManage.vue') },
    { path: '/users', name: 'UserManage', component: () => import('@/views/UserManage.vue') }
    { path: '/users', name: 'UserManage', component: () => import('@/views/UserManage.vue') },
    { path: '/holiday-stat', name: 'HolidayStat', component: () => import('@/views/HolidayStat.vue') },
    { path: '/system-config', name: 'SystemConfig', component: () => import('@/views/SystemConfig.vue'), meta: { requireAdmin: true } }
  ]
})

@@ -22,8 +24,12 @@
  const token = sessionStorage.getItem('token')
  if (to.path === '/login') {
    next(token ? '/dashboard' : undefined)
  } else if (!token) {
    next('/login')
  } else if (to.meta && to.meta.requireAdmin && sessionStorage.getItem('username') !== 'admin') {
    next('/dashboard')
  } else {
    next(token ? undefined : '/login')
    next()
  }
})


 traffic-audit-web/src/views/AuditResult.vue

@@ -10,9 +10,14 @@
          <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-submenu index="/special-stats">
            <template slot="title">专项统计</template>
            <el-menu-item index="/holiday-stat">节假日</el-menu-item>
          </el-submenu>
          <el-menu-item index="/rules">规则管理</el-menu-item>
          <el-menu-item index="/users">用户管理</el-menu-item>
</el-menu>
          <el-menu-item v-if="operatorIsAdmin" index="/system-config">系统配置</el-menu-item>
        </el-menu>
      </el-aside>
      <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>

 traffic-audit-web/src/views/Dashboard.vue

@@ -10,8 +10,14 @@
          <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-submenu index="/special-stats">
            <template slot="title">专项统计</template>
            <el-menu-item index="/holiday-stat">节假日</el-menu-item>
          </el-submenu>
          <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-item v-if="operatorIsAdmin" index="/system-config">系统配置</el-menu-item>
        </el-menu>
      </el-aside>
      <el-main>
        <div class="page-scroll">

 traffic-audit-web/src/views/DataImport.vue

@@ -10,9 +10,14 @@
          <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-submenu index="/special-stats">
            <template slot="title">专项统计</template>
            <el-menu-item index="/holiday-stat">节假日</el-menu-item>
          </el-submenu>
          <el-menu-item index="/rules">规则管理</el-menu-item>
          <el-menu-item index="/users">用户管理</el-menu-item>
</el-menu>
          <el-menu-item v-if="operatorIsAdmin" index="/system-config">系统配置</el-menu-item>
        </el-menu>
      </el-aside>
      <el-main>
        <div class="page-scroll">

 traffic-audit-web/src/views/DataView.vue

@@ -10,9 +10,14 @@
          <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-submenu index="/special-stats">
            <template slot="title">专项统计</template>
            <el-menu-item index="/holiday-stat">节假日</el-menu-item>
          </el-submenu>
          <el-menu-item index="/rules">规则管理</el-menu-item>
          <el-menu-item index="/users">用户管理</el-menu-item>
</el-menu>
          <el-menu-item v-if="operatorIsAdmin" index="/system-config">系统配置</el-menu-item>
        </el-menu>
      </el-aside>
      <el-main>
        <h3>导入数据查看</h3>

 traffic-audit-web/src/views/ExplainReview.vue

@@ -10,9 +10,14 @@
          <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-submenu index="/special-stats">
            <template slot="title">专项统计</template>
            <el-menu-item index="/holiday-stat">节假日</el-menu-item>
          </el-submenu>
          <el-menu-item index="/rules">规则管理</el-menu-item>
          <el-menu-item index="/users">用户管理</el-menu-item>
</el-menu>
          <el-menu-item v-if="operatorIsAdmin" index="/system-config">系统配置</el-menu-item>
        </el-menu>
      </el-aside>
      <el-main>
        <h3>企业解释</h3>

 traffic-audit-web/src/views/HolidayStat.vue

New file
@@ -0,0 +1,302 @@
<template>
  <el-container direction="vertical">
    <app-header title="交通统计报表审核系统 - ä¸“项统计"></app-header>
    <el-container>
      <el-aside width="200px">
        <el-menu ref="sideMenu" router :default-active="$route.path" @select="onMenuSelect">
          <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-submenu index="/special-stats">
            <template slot="title">专项统计</template>
            <el-menu-item index="/holiday-stat">节假日</el-menu-item>
          </el-submenu>
          <el-menu-item index="/rules">规则管理</el-menu-item>
          <el-menu-item index="/users">用户管理</el-menu-item>
          <el-menu-item v-if="operatorIsAdmin" index="/system-config">系统配置</el-menu-item>
        </el-menu>
      </el-aside>
      <el-main>
        <div class="page-scroll">
          <h3>专项统计 - èŠ‚假日</h3>
          <div class="toolbar">
            <el-select v-model="year" style="width:120px" @change="loadOverview">
              <el-option v-for="item in years" :key="item" :label="item + 'å¹´'" :value="item"></el-option>
            </el-select>
            <el-select v-model="holidayType" style="width:150px" @change="loadOverview">
              <el-option v-for="item in holidayTypeOptions" :key="item.value" :label="item.label" :value="item.value"></el-option>
            </el-select>
            <el-button icon="el-icon-refresh" @click="loadOverview">刷新</el-button>
            <el-button icon="el-icon-download" @click="downloadTemplate">下载模板</el-button>
          </div>

          <el-card shadow="never" class="operation-card">
            <div class="operation-row">
              <div class="operation-item">
                <span class="label">导入数据</span>
                <el-upload action="#" :auto-upload="false" :show-file-list="true" :limit="1"
                           accept=".xlsx,.xls" :on-change="onFileChange" :on-remove="onFileRemove" :file-list="fileList">
                  <el-button type="primary" plain icon="el-icon-folder-opened">选择文件</el-button>
                </el-upload>
                <el-button type="primary" icon="el-icon-upload2" :loading="importing" :disabled="!selectedFile" @click="importData">导入</el-button>
              </div>
              <div class="operation-item">
                <span class="label">导出数据</span>
                <el-button type="success" icon="el-icon-download" :loading="exporting" @click="exportData">导出 Excel</el-button>
              </div>
              <div class="operation-item">
                <span class="label">客流快报</span>
                <el-date-picker v-model="bulletinDate" type="date" value-format="yyyy-MM-dd" style="width:160px" placeholder="选择日期"></el-date-picker>
                <el-button type="warning" icon="el-icon-document" :loading="bulletinLoading" @click="downloadBulletin">下载快报</el-button>
              </div>
            </div>
          </el-card>

          <div v-if="importMessage" class="import-message">
            <pre>{{ importMessage }}</pre>
          </div>

          <el-card shadow="never" style="margin-top:14px">
            <div slot="header">{{ year }}å¹´{{ holidayTypeLabel }}节假日数据</div>
            <el-table :data="rows" border stripe size="small" v-loading="loading" style="width:100%">
              <el-table-column prop="dayIndex" label="第几日" width="80" align="center"></el-table-column>
              <el-table-column prop="date" label="日期" width="120" align="center"></el-table-column>
              <el-table-column label="铁路（万人次）" width="120" align="right"><template slot-scope="s">{{ formatNumber(s.row.rail) }}</template></el-table-column>
              <el-table-column label="民航（万人次）" width="120" align="right"><template slot-scope="s">{{ formatNumber(s.row.civilAviation) }}</template></el-table-column>
              <el-table-column label="道路（万人次）" width="120" align="right"><template slot-scope="s">{{ formatNumber(s.row.road) }}</template></el-table-column>
              <el-table-column label="水路（万人次）" width="120" align="right"><template slot-scope="s">{{ formatNumber(s.row.water) }}</template></el-table-column>
              <el-table-column label="高速车流（万辆次）" width="150" align="right"><template slot-scope="s">{{ formatNumber(s.row.expressway) }}</template></el-table-column>
              <el-table-column label="国省道车流（万辆次）" width="160" align="right"><template slot-scope="s">{{ formatNumber(s.row.nationalProvincial) }}</template></el-table-column>
              <el-table-column label="国省道环比基期（万辆次）" width="190" align="right"><template slot-scope="s">{{ formatNumber(s.row.comparisonBase) }}</template></el-table-column>
              <el-table-column label="国省道车流环比" width="140" align="right"><template slot-scope="s">{{ formatRatio(s.row.nationalProvincialRingRatio) }}</template></el-table-column>
              <el-table-column label="客运系数" width="100" align="right"><template slot-scope="s">{{ formatCoefficient(s.row.coefficient) }}</template></el-table-column>
              <el-table-column label="非营业性人员流动量（万人次）" min-width="200" align="right"><template slot-scope="s">{{ formatNumber(s.row.nonBusinessPersonFlow) }}</template></el-table-column>
              <el-table-column label="总人员流动量（万人次）" min-width="180" align="right"><template slot-scope="s">{{ formatNumber(s.row.totalPersonFlow) }}</template></el-table-column>
            </el-table>
          </el-card>
        </div>
      </el-main>
    </el-container>
  </el-container>
</template>

<script>
import api from '@/api'
import AppHeader from '@/components/AppHeader.vue'

export default {
  components: { AppHeader },
  name: 'HolidayStat',
  data() {
    return {
      years: [2024, 2025, 2026, 2027, 2028, 2029, 2030],
      year: 2026,
      holidayType: 'NATIONAL_DAY',
      holidayTypeOptions: [],
      rows: [],
      loading: false,
      importing: false,
      exporting: false,
      bulletinLoading: false,
      selectedFile: null,
      fileList: [],
      importMessage: '',
      allowHistoricalOverwrite: false,
      bulletinDate: this.previousDateString()
    }
  },
  computed: {
    holidayTypeLabel() {
      const item = this.holidayTypeOptions.find(x => x.value === this.holidayType)
      return item ? item.label : this.holidayType
    }
  },
  mounted() {
    this.loadOptions()
    this.loadOverview()
  },
  methods: {
    previousDateString() {
      const date = new Date()
      date.setDate(date.getDate() - 1)
      const month = String(date.getMonth() + 1).padStart(2, '0')
      const day = String(date.getDate()).padStart(2, '0')
      return date.getFullYear() + '-' + month + '-' + day
    },
    loadOptions() {
      api.get('/holiday/config/options').then(res => {
        const map = (res.data && res.data.holidayTypes) || {}
        this.holidayTypeOptions = Object.keys(map).map(key => ({ value: key, label: map[key] }))
      })
    },
    loadOverview() {
      this.loading = true
      api.get('/holiday/overview', { params: { year: this.year, holidayType: this.holidayType } })
        .then(res => {
          if (res.code !== 200) throw new Error(res.message || '加载失败')
          this.rows = (res.data && res.data.rows) || []
        })
        .catch(err => this.showError(err, '节假日数据加载失败'))
        .finally(() => { this.loading = false })
    },
    onFileChange(file) {
      this.selectedFile = file.raw
      this.fileList = [file]
      this.importMessage = ''
    },
    onFileRemove() {
      this.selectedFile = null
      this.fileList = []
    },
    importData(allowHistoricalOverwrite) {
      if (!this.selectedFile) return
      const allowOverwrite = allowHistoricalOverwrite === true || this.allowHistoricalOverwrite === true
      const form = new FormData()
      form.append('file', this.selectedFile)
      form.append('year', this.year)
      form.append('holidayType', this.holidayType)
      form.append('allowHistoricalOverwrite', allowOverwrite ? 'true' : 'false')
      this.importing = true
      this.importMessage = ''
      api.post('/holiday/import', form, { timeout: 120000, headers: { 'Content-Type': 'multipart/form-data' } })
        .then(res => {
          if (res.code !== 200) throw new Error(res.message || '导入失败')
          const data = res.data || {}
          if (data.confirmationRequired) {
            const changes = data.historicalChanges || []
            this.importMessage = ['检测到历史日期的数据发生变化，尚未导入。请确认是否允许覆盖：'].concat(changes).join('\n')
            this.$message.warning('检测到历史数据发生变化，请确认是否允许导入')
            this.confirmHistoricalImport(changes)
            return
          }
          const lines = [
            '导入完成：客流 ' + (data.passengerRows || 0) + ' æ¡ï¼Œè½¦æµ ' + (data.vehicleRows || 0) + ' æ¡ï¼Œè·³è¿‡ç©ºç™½ ' + (data.skippedRows || 0) + ' æ¡ã€‚'
          ]
          if (data.errors && data.errors.length) {
            lines.push('失败明细：')
            data.errors.forEach(item => lines.push(item))
          }
          this.importMessage = lines.join('\n')
          this.allowHistoricalOverwrite = false
          this.$message.success('导入完成')
          this.loadOverview()
        })
        .catch(err => {
          this.allowHistoricalOverwrite = false
          this.showError(err, '导入失败')
        })
        .finally(() => { this.importing = false })
    },
    confirmHistoricalImport(changes) {
      const rows = (changes && changes.length ? changes : ['历史数据发生变化']).map(this.escapeHtml)
      const html = '<div>检测到已发布日期的数据发生变化。允许导入将覆盖这些历史数据。</div>'
        + '<pre style="max-height:320px;overflow:auto;white-space:pre-wrap;margin-top:10px;background:#f7f7f7;padding:8px;border:1px solid #e4e7ed;">'
        + rows.join('\n') + '</pre>'
      this.$confirm(html, '历史数据发生变化', {
        dangerouslyUseHTMLString: true,
        confirmButtonText: '允许导入',
        cancelButtonText: '不允许',
        type: 'warning',
        distinguishCancelAndClose: true
      }).then(() => {
        this.allowHistoricalOverwrite = true
        this.importData(true)
      }).catch(() => {
        this.allowHistoricalOverwrite = false
      })
    },
    escapeHtml(value) {
      return String(value === null || value === undefined ? '' : value)
        .replace(/&/g, '&amp;')
        .replace(/</g, '&lt;')
        .replace(/>/g, '&gt;')
        .replace(/"/g, '&quot;')
        .replace(/'/g, '&#39;')
    },
    exportData() {
      this.exporting = true
      api.get('/holiday/export', { params: { year: this.year, holidayType: this.holidayType }, responseType: 'blob', timeout: 120000 })
        .then(res => { this.downloadBlob(res, this.year + 'å¹´' + this.holidayTypeLabel + '数据.xlsx'); this.$message.success('导出成功') })
        .catch(err => this.handleBlobError(err, '导出失败'))
        .finally(() => { this.exporting = false })
    },
    downloadTemplate() {
      const templatePath = '专项统计/重要节假日/2026年十一数据.xlsx'
      const encodedPath = templatePath.split('/').map(encodeURIComponent).join('/')
      api.get('/templates/' + encodedPath, { responseType: 'blob' })
        .then(res => { this.downloadBlob(res, '2026年十一数据.xlsx'); this.$message.success('模板下载成功') })
        .catch(err => this.handleBlobError(err, '模板下载失败'))
    },
    downloadBulletin() {
      this.bulletinLoading = true
      api.get('/holiday/bulletin', { params: { date: this.bulletinDate }, responseType: 'blob', timeout: 120000 })
        .then(res => {
          const day = Number((this.bulletinDate || '').slice(-2))
          this.downloadBlob(res, '湖北省国庆假期综合运输客流快报（10月' + day + '日）.docx')
          this.$message.success('快报下载成功')
        })
        .catch(err => this.handleBlobError(err, '快报生成失败'))
        .finally(() => { this.bulletinLoading = false })
    },
    downloadBlob(data, fileName) {
      const blob = data instanceof Blob ? data : new Blob([data])
      const url = window.URL.createObjectURL(blob)
      const link = document.createElement('a')
      link.href = url
      link.download = fileName
      document.body.appendChild(link)
      link.click()
      document.body.removeChild(link)
      window.URL.revokeObjectURL(url)
    },
    handleBlobError(err, fallback) {
      if (err && err.response && err.response.data instanceof Blob) {
        err.response.data.text().then(text => {
          try {
            const parsed = JSON.parse(text)
            this.$message.error(parsed.message || fallback)
          } catch (e) {
            this.$message.error(fallback)
          }
        })
        return
      }
      this.showError(err, fallback)
    },
    showError(err, fallback) {
      if (err && err._toast) return
      const data = err && err.response && err.response.data
      this.$message.error((data && data.message) || (err && err.message) || fallback)
    },
    formatNumber(value) {
      if (value === null || value === undefined || value === '') return '—'
      return Number(value).toFixed(2)
    },
    formatCoefficient(value) {
      if (value === null || value === undefined || value === '') return '—'
      const number = Number(value)
      if (!Number.isFinite(number)) return value
      return number.toFixed(15).replace(/0+$/, '').replace(/\.$/, '')
    },
    formatRatio(value) {
      if (value === null || value === undefined || value === '') return '—'
      const number = Number(value)
      if (!Number.isFinite(number)) return value
      return (number * 100).toFixed(2) + '%'
    }
  }
}
</script>

<style scoped>
.toolbar { display: flex; gap: 8px; align-items: center; margin-bottom: 12px; }
.operation-card { margin-top: 12px; }
.operation-row { display: flex; gap: 36px; align-items: flex-start; flex-wrap: wrap; }
.operation-item { display: flex; align-items: center; gap: 8px; }
.operation-item .label { color: #606266; font-size: 14px; }
.import-message { margin-top: 12px; padding: 10px 12px; background: #f5f7fa; border: 1px solid #e4e7ed; border-radius: 4px; }
.import-message pre { margin: 0; white-space: pre-wrap; font-family: inherit; color: #606266; }
</style>

 traffic-audit-web/src/views/ReportExport.vue

@@ -10,8 +10,13 @@
          <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-submenu index="/special-stats">
            <template slot="title">专项统计</template>
            <el-menu-item index="/holiday-stat">节假日</el-menu-item>
          </el-submenu>
          <el-menu-item index="/rules">规则管理</el-menu-item>
          <el-menu-item index="/users">用户管理</el-menu-item>
          <el-menu-item v-if="operatorIsAdmin" index="/system-config">系统配置</el-menu-item>
        </el-menu>
      </el-aside>
      <el-main>

 traffic-audit-web/src/views/RuleManage.vue

@@ -10,8 +10,13 @@
          <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-submenu index="/special-stats">
            <template slot="title">专项统计</template>
            <el-menu-item index="/holiday-stat">节假日</el-menu-item>
          </el-submenu>
          <el-menu-item index="/rules">规则管理</el-menu-item>
          <el-menu-item index="/users">用户管理</el-menu-item>
          <el-menu-item v-if="operatorIsAdmin" index="/system-config">系统配置</el-menu-item>
        </el-menu>
      </el-aside>
      <el-main>

 traffic-audit-web/src/views/SystemConfig.vue

New file
@@ -0,0 +1,295 @@
<template>
  <el-container direction="vertical">
    <app-header title="交通统计报表审核系统 - ç³»ç»Ÿé…ç½®"></app-header>
    <el-container>
      <el-aside width="200px">
        <el-menu ref="sideMenu" router :default-active="$route.path" @select="onMenuSelect">
          <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-submenu index="/special-stats">
            <template slot="title">专项统计</template>
            <el-menu-item index="/holiday-stat">节假日</el-menu-item>
          </el-submenu>
          <el-menu-item index="/rules">规则管理</el-menu-item>
          <el-menu-item index="/users">用户管理</el-menu-item>
          <el-menu-item v-if="operatorIsAdmin" index="/system-config">系统配置</el-menu-item>
        </el-menu>
      </el-aside>
      <el-main>
        <div class="page-scroll">
          <h3>系统配置</h3>
          <el-tabs v-model="activeTab" @tab-click="loadActiveTab">
            <el-tab-pane label="节假日管理" name="holidays">
              <div class="toolbar">
                <el-select v-model="holidayQuery.year" clearable placeholder="年份" style="width:130px" @change="loadHolidays">
                  <el-option v-for="year in years" :key="year" :label="year + 'å¹´'" :value="year"></el-option>
                </el-select>
                <el-select v-model="holidayQuery.holidayType" clearable placeholder="节假日分类" style="width:150px" @change="loadHolidays">
                  <el-option v-for="item in holidayTypeOptions" :key="item.value" :label="item.label" :value="item.value"></el-option>
                </el-select>
                <el-button type="primary" icon="el-icon-search" @click="loadHolidays">查询</el-button>
                <el-button type="success" icon="el-icon-plus" @click="openHolidayDialog()">新增节假日</el-button>
              </div>
              <el-table :data="holidays" border stripe size="small" v-loading="loadingHolidays" style="width:100%">
                <el-table-column prop="year" label="年份" width="100" align="center"></el-table-column>
                <el-table-column label="节假日分类" width="140">
                  <template slot-scope="scope">{{ labelOf(holidayTypeOptions, scope.row.holidayType) }}</template>
                </el-table-column>
                <el-table-column prop="holidayDate" label="日期" width="150" align="center"></el-table-column>
                <el-table-column prop="dayIndex" label="第几日" width="100" align="center"></el-table-column>
                <el-table-column label="操作" width="150" align="center">
                  <template slot-scope="scope">
                    <el-button type="text" size="mini" @click="openHolidayDialog(scope.row)">编辑</el-button>
                    <el-button type="text" size="mini" class="danger-text" @click="removeHoliday(scope.row)">删除</el-button>
                  </template>
                </el-table-column>
              </el-table>
            </el-tab-pane>

            <el-tab-pane label="客运系数管理" name="coefficients">
              <div class="toolbar">
                <el-select v-model="coefficientQuery.year" clearable placeholder="年份" style="width:130px" @change="loadCoefficients">
                  <el-option v-for="year in years" :key="year" :label="year + 'å¹´'" :value="year"></el-option>
                </el-select>
                <el-button type="primary" icon="el-icon-search" @click="loadCoefficients">查询</el-button>
                <el-button type="success" icon="el-icon-plus" @click="openCoefficientDialog()">新增客运系数</el-button>
              </div>
              <el-table :data="coefficients" border stripe size="small" v-loading="loadingCoefficients" style="width:100%">
                <el-table-column prop="year" label="年份" width="120" align="center"></el-table-column>
                <el-table-column label="日期分类" width="160">
                  <template slot-scope="scope">{{ labelOf(dateCategoryOptions, scope.row.dateCategory) }}</template>
                </el-table-column>
                <el-table-column label="客运系数" width="160" align="center">
                  <template slot-scope="scope">{{ formatCoefficient(scope.row.coefficient) }}</template>
                </el-table-column>
                <el-table-column label="操作" width="150" align="center">
                  <template slot-scope="scope">
                    <el-button type="text" size="mini" @click="openCoefficientDialog(scope.row)">编辑</el-button>
                    <el-button type="text" size="mini" class="danger-text" @click="removeCoefficient(scope.row)">删除</el-button>
                  </template>
                </el-table-column>
              </el-table>
            </el-tab-pane>
          </el-tabs>
        </div>

        <el-dialog :title="holidayForm.id ? '编辑节假日' : '新增节假日'" :visible.sync="holidayDialog" width="520px" v-dialog-drag>
          <el-form ref="holidayForm" :model="holidayForm" :rules="holidayRules" label-width="110px">
            <el-form-item label="年份" prop="year">
              <el-select v-model="holidayForm.year" style="width:100%" @change="onHolidayYearChange">
                <el-option v-for="year in years" :key="year" :label="year + 'å¹´'" :value="year"></el-option>
              </el-select>
            </el-form-item>
            <el-form-item label="节假日分类" prop="holidayType">
              <el-select v-model="holidayForm.holidayType" style="width:100%">
                <el-option v-for="item in holidayTypeOptions" :key="item.value" :label="item.label" :value="item.value"></el-option>
              </el-select>
            </el-form-item>
            <el-form-item label="日期" prop="holidayDate">
              <el-date-picker v-model="holidayForm.holidayDate" type="date" value-format="yyyy-MM-dd"
                              style="width:100%" placeholder="选择日期"></el-date-picker>
            </el-form-item>
            <el-form-item label="第几日" prop="dayIndex">
              <el-input-number v-model="holidayForm.dayIndex" :min="1" :max="31" style="width:100%"></el-input-number>
            </el-form-item>
          </el-form>
          <span slot="footer">
            <el-button @click="holidayDialog = false">取消</el-button>
            <el-button type="primary" :loading="saving" @click="saveHoliday">保存</el-button>
          </span>
        </el-dialog>

        <el-dialog :title="coefficientForm.id ? '编辑客运系数' : '新增客运系数'" :visible.sync="coefficientDialog" width="520px" v-dialog-drag>
          <el-form ref="coefficientForm" :model="coefficientForm" :rules="coefficientRules" label-width="110px">
            <el-form-item label="年份" prop="year">
              <el-select v-model="coefficientForm.year" style="width:100%">
                <el-option v-for="year in years" :key="year" :label="year + 'å¹´'" :value="year"></el-option>
              </el-select>
            </el-form-item>
            <el-form-item label="日期分类" prop="dateCategory">
              <el-select v-model="coefficientForm.dateCategory" style="width:100%">
                <el-option v-for="item in dateCategoryOptions" :key="item.value" :label="item.label" :value="item.value"></el-option>
              </el-select>
            </el-form-item>
            <el-form-item label="客运系数" prop="coefficient">
              <el-input-number v-model="coefficientForm.coefficient" :min="0.01" :precision="4" :step="0.1" style="width:100%"></el-input-number>
            </el-form-item>
          </el-form>
          <span slot="footer">
            <el-button @click="coefficientDialog = false">取消</el-button>
            <el-button type="primary" :loading="saving" @click="saveCoefficient">保存</el-button>
          </span>
        </el-dialog>
      </el-main>
    </el-container>
  </el-container>
</template>

<script>
import api from '@/api'
import AppHeader from '@/components/AppHeader.vue'

export default {
  components: { AppHeader },
  name: 'SystemConfig',
  data() {
    return {
      activeTab: 'holidays',
      years: [2024, 2025, 2026, 2027, 2028, 2029, 2030],
      holidayTypeOptions: [],
      dateCategoryOptions: [],
      holidayQuery: { year: 2026, holidayType: 'NATIONAL_DAY' },
      coefficientQuery: { year: 2026 },
      holidays: [],
      coefficients: [],
      loadingHolidays: false,
      loadingCoefficients: false,
      saving: false,
      holidayDialog: false,
      coefficientDialog: false,
      holidayForm: { id: null, year: 2026, holidayType: 'NATIONAL_DAY', holidayDate: '', dayIndex: 1 },
      coefficientForm: { id: null, year: 2026, dateCategory: 'HOLIDAY', coefficient: 2.4 },
      holidayRules: {
        year: [{ required: true, message: '请选择年份', trigger: 'change' }],
        holidayType: [{ required: true, message: '请选择节假日分类', trigger: 'change' }],
        holidayDate: [{ required: true, message: '请选择日期', trigger: 'change' }],
        dayIndex: [{ required: true, message: '请输入第几日', trigger: 'change' }]
      },
      coefficientRules: {
        year: [{ required: true, message: '请选择年份', trigger: 'change' }],
        dateCategory: [{ required: true, message: '请选择日期分类', trigger: 'change' }],
        coefficient: [{ required: true, message: '请输入客运系数', trigger: 'change' }]
      }
    }
  },
  mounted() {
    this.loadOptions()
    this.loadHolidays()
    this.loadCoefficients()
  },
  methods: {
    loadOptions() {
      api.get('/holiday/config/options').then(res => {
        const data = res.data || {}
        this.holidayTypeOptions = this.mapOptions(data.holidayTypes)
        this.dateCategoryOptions = this.mapOptions(data.dateCategories)
      })
    },
    mapOptions(map) {
      if (!map) return []
      return Object.keys(map).map(key => ({ value: key, label: map[key] }))
    },
    labelOf(options, value) {
      const item = (options || []).find(x => x.value === value)
      return item ? item.label : value
    },
    loadActiveTab() {
      if (this.activeTab === 'holidays') this.loadHolidays()
      else this.loadCoefficients()
    },
    loadHolidays() {
      this.loadingHolidays = true
      api.get('/holiday/config/holidays', { params: this.holidayQuery })
        .then(res => { this.holidays = res.data || [] })
        .catch(e => { if (!e || !e._toast) this.$message.error('节假日加载失败') })
        .finally(() => { this.loadingHolidays = false })
    },
    loadCoefficients() {
      this.loadingCoefficients = true
      api.get('/holiday/config/coefficients', { params: this.coefficientQuery })
        .then(res => { this.coefficients = res.data || [] })
        .catch(e => { if (!e || !e._toast) this.$message.error('客运系数加载失败') })
        .finally(() => { this.loadingCoefficients = false })
    },
    openHolidayDialog(row) {
      this.holidayDialog = true
      this.$nextTick(() => {
        this.holidayForm = row ? Object.assign({}, row) : { id: null, year: 2026, holidayType: 'NATIONAL_DAY', holidayDate: '', dayIndex: 1 }
        if (this.$refs.holidayForm) this.$refs.holidayForm.clearValidate()
      })
    },
    onHolidayYearChange(year) {
      if (this.holidayForm.holidayDate && Number(this.holidayForm.holidayDate.slice(0, 4)) !== year) {
        this.holidayForm.holidayDate = ''
      }
    },
    saveHoliday() {
      this.$refs.holidayForm.validate(valid => {
        if (!valid) return
        this.saving = true
        api.post('/holiday/config/holidays/save', this.holidayForm)
          .then(res => {
            if (res.code !== 200) throw new Error(res.message || '保存失败')
            this.$message.success('保存成功')
            this.holidayDialog = false
            this.loadHolidays()
          })
          .catch(err => this.showError(err, '保存失败'))
          .finally(() => { this.saving = false })
      })
    },
    removeHoliday(row) {
      this.$confirm('确定删除该节假日日期吗？', '删除确认', { type: 'warning' })
        .then(() => api.post('/holiday/config/holidays/delete', null, { params: { id: row.id } }))
        .then(res => {
          if (res.code !== 200) throw new Error(res.message || '删除失败')
          this.$message.success('已删除')
          this.loadHolidays()
        })
        .catch(err => { if (err !== 'cancel') this.showError(err, '删除失败') })
    },
    openCoefficientDialog(row) {
      this.coefficientDialog = true
      this.$nextTick(() => {
        this.coefficientForm = row ? Object.assign({}, row) : { id: null, year: 2026, dateCategory: 'HOLIDAY', coefficient: 2.4 }
        if (this.$refs.coefficientForm) this.$refs.coefficientForm.clearValidate()
      })
    },
    saveCoefficient() {
      this.$refs.coefficientForm.validate(valid => {
        if (!valid) return
        this.saving = true
        api.post('/holiday/config/coefficients/save', this.coefficientForm)
          .then(res => {
            if (res.code !== 200) throw new Error(res.message || '保存失败')
            this.$message.success('保存成功')
            this.coefficientDialog = false
            this.loadCoefficients()
          })
          .catch(err => this.showError(err, '保存失败'))
          .finally(() => { this.saving = false })
      })
    },
    removeCoefficient(row) {
      this.$confirm('确定删除该客运系数吗？', '删除确认', { type: 'warning' })
        .then(() => api.post('/holiday/config/coefficients/delete', null, { params: { id: row.id } }))
        .then(res => {
          if (res.code !== 200) throw new Error(res.message || '删除失败')
          this.$message.success('已删除')
          this.loadCoefficients()
        })
        .catch(err => { if (err !== 'cancel') this.showError(err, '删除失败') })
    },
    formatCoefficient(value) {
      if (value === null || value === undefined || value === '') return '—'
      const number = Number(value)
      if (!Number.isFinite(number)) return value
      return number.toFixed(15).replace(/0+$/, '').replace(/\.$/, '')
    },
    showError(err, fallback) {
      if (err && err._toast) return
      const data = err && err.response && err.response.data
      this.$message.error((data && data.message) || (err && err.message) || fallback)
    }
  }
}
</script>

<style scoped>
.toolbar { margin-bottom: 12px; display: flex; gap: 8px; align-items: center; }
.danger-text { color: #f56c6c; }
</style>

 traffic-audit-web/src/views/UserManage.vue

@@ -10,8 +10,13 @@
          <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-submenu index="/special-stats">
            <template slot="title">专项统计</template>
            <el-menu-item index="/holiday-stat">节假日</el-menu-item>
          </el-submenu>
          <el-menu-item index="/rules">规则管理</el-menu-item>
          <el-menu-item index="/users">用户管理</el-menu-item>
          <el-menu-item v-if="operatorIsAdmin" index="/system-config">系统配置</el-menu-item>
        </el-menu>
      </el-aside>
      <el-main>