From 103ceb6c2e0cecae2678d1fd1471c85a9b94e6f4 Mon Sep 17 00:00:00 2001
From: Nixevol <guaotiantang@gmail.com>
Date: Tue, 13 Jan 2026 19:07:07 +0800
Subject: [PATCH] v2.0.0 done

---
 .gitignore           |   75 ++
 Configure.json       |  242 +++++
 Dockerfile           |   24 +
 README.md            |  139 +++
 ReportScript.sql     |  471 ++++++++++
 app/config.py        |  109 +++
 app/database.py      |  262 ++++++
 app/history.py       |  221 +++++
 app/main.py          |  907 +++++++++++++++++++
 app/processor.py     |  426 +++++++++
 requirements.txt     |   22 +
 run.bat              |   40 +
 static/css/style.css | 1992 ++++++++++++++++++++++++++++++++++++++++++
 static/index.html    |  414 +++++++++
 static/js/app.js     | 1973 +++++++++++++++++++++++++++++++++++++++++
 supervisord.conf     |   29 +
 16 files changed, 7346 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 Configure.json
 create mode 100644 Dockerfile
 create mode 100644 README.md
 create mode 100644 ReportScript.sql
 create mode 100644 app/config.py
 create mode 100644 app/database.py
 create mode 100644 app/history.py
 create mode 100644 app/main.py
 create mode 100644 app/processor.py
 create mode 100644 requirements.txt
 create mode 100644 run.bat
 create mode 100644 static/css/style.css
 create mode 100644 static/index.html
 create mode 100644 static/js/app.js
 create mode 100644 supervisord.conf

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..18b5d6d
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,75 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual Environment
+.venv/
+venv/
+ENV/
+env/
+.ENV
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# 项目特定目录
+cache/
+bak/
+CapacityReportData/
+
+# 日志文件
+*.log
+logs/
+
+# 环境变量
+.env
+.env.local
+
+# 数据库
+*.db
+*.sqlite
+*.sqlite3
+
+# 临时文件
+*.tmp
+*.temp
+*.bak
+*.cache
+
+# 系统文件
+Thumbs.db
+desktop.ini
+
+# 上传的文件
+uploads/
+*.zip
+*.xlsx
+*.xls
+*.csv
+
+# 配置文件（如果包含敏感信息）
+# Configure.json  # 如果需要保留配置，注释掉这行
diff --git a/Configure.json b/Configure.json
new file mode 100644
index 0000000..a12d0b5
--- /dev/null
+++ b/Configure.json
@@ -0,0 +1,242 @@
+{
+  "Update": "2026/01/13 18:04:33",
+  "MySQL_DBInfo": {
+    "host": "127.0.0.1",
+    "port": 3306,
+    "user": "root",
+    "passwd": "242520",
+    "dbname": "CapacityReport"
+  },
+  "SheetFilter": [
+    "指标(计数器)",
+    "Template"
+  ],
+  "ExtractField": [
+    {
+      "Field": "日期时间",
+      "Extract": [
+        "开始时间"
+      ]
+    },
+    {
+      "Field": "网元ID",
+      "Extract": [
+        "网元ID",
+        "网元"
+      ]
+    },
+    {
+      "Field": "eNodeBId",
+      "Extract": [
+        "eNodeBId",
+        "eNodeB"
+      ]
+    },
+    {
+      "Field": "cellLocalId",
+      "Extract": [
+        "cellId",
+        "小区"
+      ]
+    },
+    {
+      "Field": "基站名称",
+      "Extract": [
+        "eNodeB CU名称",
+        "eNodeB名称"
+      ]
+    },
+    {
+      "Field": "小区名称",
+      "Extract": [
+        "小区名称",
+        "E-UTRAN FDD小区名称",
+        "E-UTRAN TDD小区名称"
+      ]
+    },
+    {
+      "Field": "上下行总流量_GB",
+      "Extract": [
+        "集团-上下行总业务量（GB）",
+        "业务流量上下行（GB）",
+        "YJ_业务流量上下行（GB）",
+        "FDD总流量（G）"
+      ]
+    },
+    {
+      "Field": "ERAB流量",
+      "Extract": [
+        "ERAB流量(新高负荷)",
+        "ERAB流量",
+        "ERAB流量(新高负荷)",
+        "ERAB流量(新高负荷)-FDD"
+      ]
+    },
+    {
+      "Field": "上行流量_GB",
+      "Extract": [
+        "上行流量(新高负荷GB)",
+        "上行流量(新高负荷GB)",
+        "高负荷-上行流量(GB)",
+        "FDD上行流量（G）"
+      ]
+    },
+    {
+      "Field": "下行流量_GB",
+      "Extract": [
+        "下行流量(新高负荷GB)",
+        "下行流量(新高负荷GB)",
+        "高负荷-下行流量(GB)",
+        "FDD下行流量（G）"
+      ]
+    },
+    {
+      "Field": "用户面平均激活UE数",
+      "Extract": [
+        "用户面平均激活UE数",
+        "YY-用户面平均激活UE数(个)",
+        "用户面平均激活UE数(unit)"
+      ]
+    },
+    {
+      "Field": "RRC连接建立最大用户数",
+      "Extract": [
+        "YY-RRC连接建立最大用户数(个)",
+        "RRC连接建立最大用户数(unit)",
+        "RRC连接建立最大用户数"
+      ]
+    },
+    {
+      "Field": "上行PUSCH利用率",
+      "Extract": [
+        "上行PUSCH利用率",
+        "YY-上行PUSCH利用率",
+        "上行PUSCH利用率-FDD"
+      ]
+    },
+    {
+      "Field": "下行PDSCH利用率",
+      "Extract": [
+        "下行PDSCH利用率",
+        "YY-下行PDSCH利用率",
+        "下行PDSCH利用率-FDD"
+      ]
+    },
+    {
+      "Field": "PDCCH资源利用率",
+      "Extract": [
+        "PDCCH资源利用率",
+        "PDCCH资源利用率_1548034713403-33-2",
+        "PDCCH资源使用率(%)"
+      ]
+    },
+    {
+      "Field": "用户面最大激活UE数",
+      "Extract": [
+        "开发者大会保障--最大激活UE数",
+        "用户面最大激活UE数",
+        "YY-用户面最大激活UE数(个)",
+        "用户面最大激活UE数(unit)"
+      ]
+    },
+    {
+      "Field": "CU小区配置名称",
+      "Extract": [
+        "CU小区配置名称"
+      ]
+    },
+    {
+      "Field": "gNBId",
+      "Extract": [
+        "gNBId"
+      ]
+    },
+    {
+      "Field": "gNBplmn",
+      "Extract": [
+        "gNBplmn"
+      ]
+    },
+    {
+      "Field": "5G上下行总流量_GB",
+      "Extract": [
+        "5G上下行总流量（上行PDCP PDU数据量+下行PDCP成功发送数据量）(GB)"
+      ]
+    },
+    {
+      "Field": "5G上行流量_GB",
+      "Extract": [
+        "5G上行流量（上行PDCP PDU数据量）_1603677232210(GB)",
+        "5G上行流量（上行PDCP PDU数据量）(GB)"
+      ]
+    },
+    {
+      "Field": "5G下行流量_GB",
+      "Extract": [
+        "5G下行流量（下行PDCP成功发送数据量）_1603677232245(GB)",
+        "5G下行流量（下行PDCP成功发送数据量）(GB)"
+      ]
+    },
+    {
+      "Field": "小区平均激活UE数",
+      "Extract": [
+        "小区平均激活UE数"
+      ]
+    },
+    {
+      "Field": "RRC连接最大连接用户数",
+      "Extract": [
+        "RRC连接最大连接用户数"
+      ]
+    },
+    {
+      "Field": "RRC连接平均连接用户数",
+      "Extract": [
+        "RRC连接平均连接用户数"
+      ]
+    },
+    {
+      "Field": "小区最大激活UE数",
+      "Extract": [
+        "小区最大激活UE数"
+      ]
+    },
+    {
+      "Field": "上行PRB平均利用率",
+      "Extract": [
+        "上行PRB平均利用率"
+      ]
+    },
+    {
+      "Field": "下行PRB平均利用率",
+      "Extract": [
+        "下行PRB平均利用率"
+      ]
+    },
+    {
+      "Field": "小区下行RLC_SDU字节数_MByte",
+      "Extract": [
+        "小区下行RLC SDU字节数(MByte)"
+      ]
+    },
+    {
+      "Field": "小区上行RLC_SDU字节数_MByte",
+      "Extract": [
+        "小区上行RLC SDU字节数(MByte)"
+      ]
+    },
+    {
+      "Field": "PDCCH信道动态CCE占用率",
+      "Extract": [
+        "PDCCH信道CCE占用率（动态）(%)"
+      ]
+    },
+    {
+      "Field": "平均单Flow流量_MB",
+      "Extract": [
+        "平均单Flow流量(MB)",
+        "平均每flow流量（流量/flow(MB/flow)）"
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000..db9bae7
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,24 @@
+FROM python:3.11
+
+WORKDIR /app
+
+# 复制依赖文件
+COPY requirements.txt ./
+
+# 安装依赖
+RUN pip install --no-cache-dir -r requirements.txt
+
+# 创建日志目录
+RUN mkdir -p /var/log/supervisor /var/run
+
+# 复制应用代码
+COPY . .
+
+# 设置启动脚本权限
+RUN chmod +x /app/start.sh
+
+# 暴露端口
+EXPOSE 9081
+
+# 使用启动脚本
+CMD ["/app/start.sh"]
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..9e8c81a
--- /dev/null
+++ b/README.md
@@ -0,0 +1,139 @@
+# CapacityReport - 容量报表处理程序
+
+容量报表数据处理系统，支持 Excel/CSV 文件上传、数据提取、清洗和导入 MySQL 数据库。
+
+## 技术栈
+
+- **后端**: FastAPI + Uvicorn + Supervisor
+- **前端**: 原生 JavaScript + HTML/CSS
+- **数据库**: MySQL (PyMySQL + SQLAlchemy)
+- **数据处理**: Pandas + OpenPyXL
+- **部署**: Docker + Supervisor
+
+## 系统架构
+
+```mermaid
+graph TB
+    A[浏览器] -->|HTTP| B[FastAPI]
+    B -->|静态文件| C[Static Files]
+    B -->|API请求| D[业务逻辑层]
+    D -->|数据处理| E[DataProcessor]
+    D -->|数据管理| F[DatabaseManager]
+    D -->|历史记录| G[HistoryManager]
+    E -->|批量插入| H[MySQL]
+    F -->|连接池| H
+    I[Supervisor] -->|管理进程| J[Uvicorn]
+    J -->|运行| B
+```
+
+## 核心模块
+
+- `app/main.py` - FastAPI 应用入口，API 路由
+- `app/processor.py` - 数据处理核心（ZIP解压、Excel转CSV、CSV导入）
+- `app/database.py` - 数据库连接与批量插入
+- `app/history.py` - 处理历史记录管理
+- `app/config.py` - 配置管理
+
+## 数据流程
+
+```mermaid
+flowchart TD
+    A[上传文件] --> B{文件类型}
+    B -->|ZIP| C[解压ZIP]
+    B -->|Excel| D[Excel转CSV]
+    B -->|CSV| E[直接处理]
+    C --> D
+    D --> F[字段映射]
+    E --> F
+    F --> G[数据清洗]
+    G --> H[批量插入MySQL]
+    H --> I[执行SQL脚本]
+    I --> J[生成结果表]
+```
+
+## 上传处理时序
+
+```mermaid
+sequenceDiagram
+    participant U as 用户
+    participant F as 前端
+    participant A as FastAPI
+    participant P as DataProcessor
+    participant D as MySQL
+
+    U->>F: 选择文件上传
+    F->>A: POST /api/upload
+    A->>A: 保存文件到 cache/
+    A->>F: 返回 task_id
+    F->>A: POST /api/process/start
+    A->>P: 启动处理任务
+    P->>P: 解压ZIP/处理Excel
+    P->>P: 读取CSV并清洗
+    P->>D: 批量插入数据
+    P->>D: 执行SQL脚本
+    P->>A: 返回处理结果
+    A->>F: 推送日志更新
+    F->>U: 显示处理进度
+```
+
+
+
+## 部署
+
+### Docker 部署
+
+```bash
+docker build -t capareport .
+docker run -d --restart=always -p 9081:9081 capareport
+```
+
+### Windows 部署
+
+```bash
+# 安装依赖
+pip install -r requirements.txt
+
+# 启动服务（自动重启模式）
+run.bat
+```
+
+### Linux 部署
+
+```bash
+# 使用 Supervisor
+supervisord -c supervisord.conf
+```
+
+## 配置
+
+配置文件: `Configure.json`
+
+- `MySQL_DBInfo` - 数据库连接信息
+- `SheetFilter` - Excel Sheet 过滤规则
+- `ExtractField` - 字段映射配置
+
+## API 端点
+
+- `POST /api/upload` - 上传文件
+- `POST /api/process/start` - 启动处理
+- `POST /api/process/status` - 查询处理状态
+- `POST /api/history` - 获取历史记录
+- `POST /api/service/restart` - 重启服务
+- `GET /api/service/status` - 服务状态
+
+## 目录结构
+
+```
+CapaReport/
+├── app/              # 应用代码
+│   ├── main.py       # FastAPI 入口
+│   ├── processor.py  # 数据处理
+│   ├── database.py   # 数据库管理
+│   ├── history.py    # 历史记录
+│   └── config.py     # 配置管理
+├── static/           # 前端静态文件
+├── cache/            # 临时文件目录
+├── Configure.json    # 配置文件
+├── Dockerfile        # Docker 配置
+└── supervisord.conf  # Supervisor 配置
+```
diff --git a/ReportScript.sql b/ReportScript.sql
new file mode 100644
index 0000000..5a1f6c6
--- /dev/null
+++ b/ReportScript.sql
@@ -0,0 +1,471 @@
+# Update: 2024/11/25 09:30:00
+
+SET GLOBAL wait_timeout = 86400;
+DROP TABLE IF EXISTS `4G`;
+DROP TABLE IF EXISTS `5G`;
+DROP TABLE IF EXISTS `4G_Date`;
+DROP TABLE IF EXISTS `4G_MAX`;
+DROP TABLE IF EXISTS `CCE_MAX`;
+DROP TABLE IF EXISTS `ULPRB_MAX`;
+DROP TABLE IF EXISTS `DLPRB_MAX`;
+DROP TABLE IF EXISTS `4G_MAX_IDX`;
+DROP TABLE IF EXISTS `CCE_MAX_IDX`;
+DROP TABLE IF EXISTS `ULPRB_MAX_IDX`;
+DROP TABLE IF EXISTS `DLPRB_MAX_IDX`;
+DROP TABLE IF EXISTS `日流量`;
+DROP TABLE IF EXISTS `4G日均流量`;
+DROP TABLE IF EXISTS `4G_结果表`;
+
+DROP TABLE IF EXISTS `5G_Date`;
+DROP TABLE IF EXISTS `5G_MAX`;
+DROP TABLE IF EXISTS `5G_MAX_IDX`;
+DROP TABLE IF EXISTS `5G日均流量`;
+DROP TABLE IF EXISTS `5G_结果表`;
+
+
+CREATE TABLE `4G` AS SELECT * FROM `4G_UD`;
+CREATE TABLE `5G` AS SELECT * FROM `5G_UD`;
+
+UPDATE 4G SET `日期时间` = DATE_FORMAT(`日期时间`, '%Y-%m-%d %H:%i:%s');
+UPDATE 5G SET `日期时间` = DATE_FORMAT(`日期时间`, '%Y-%m-%d %H:%i:%s');
+
+ALTER TABLE `4G`
+ADD COLUMN `日期` date NULL FIRST,
+MODIFY COLUMN `日期时间` datetime,
+ADD COLUMN `CGI` varchar(100) NULL AFTER `日期时间`,
+MODIFY COLUMN `网元ID` int,
+MODIFY COLUMN `基站名称` varchar(200),
+MODIFY COLUMN `小区名称` varchar(200),
+MODIFY COLUMN `cellLocalId` int,
+MODIFY COLUMN `eNodeBId` int,
+MODIFY COLUMN `上下行总流量_GB` float,
+MODIFY COLUMN `ERAB流量` float,
+MODIFY COLUMN `上行流量_GB` float,
+MODIFY COLUMN `下行流量_GB` float,
+MODIFY COLUMN `用户面平均激活UE数` float,
+MODIFY COLUMN `RRC连接建立最大用户数` int,
+MODIFY COLUMN `上行PUSCH利用率` float,
+MODIFY COLUMN `下行PDSCH利用率` float,
+MODIFY COLUMN `PDCCH资源利用率` float,
+MODIFY COLUMN `用户面最大激活UE数` int;
+
+ALTER TABLE `5G`
+ADD COLUMN `日期` date NULL FIRST,
+MODIFY COLUMN `日期时间` datetime,
+ADD COLUMN `NCGI` varchar(100) NULL AFTER `日期时间`,
+MODIFY COLUMN `网元ID` int,
+MODIFY COLUMN `CU小区配置名称` varchar(200),
+MODIFY COLUMN `cellLocalId` int,
+MODIFY COLUMN `gNBId` int,
+MODIFY COLUMN `gNBplmn` varchar(200),
+MODIFY COLUMN `5G上下行总流量_GB` float,
+MODIFY COLUMN `5G上行流量_GB` float,
+MODIFY COLUMN `5G下行流量_GB` float,
+MODIFY COLUMN `小区平均激活UE数` float,
+MODIFY COLUMN `RRC连接最大连接用户数` int,
+MODIFY COLUMN `RRC连接平均连接用户数` float,
+MODIFY COLUMN `小区最大激活UE数` float,
+MODIFY COLUMN `上行PRB平均利用率` float,
+MODIFY COLUMN `下行PRB平均利用率` float,
+MODIFY COLUMN `小区下行RLC_SDU字节数_MByte` float,
+MODIFY COLUMN `小区上行RLC_SDU字节数_MByte` float,
+MODIFY COLUMN `PDCCH信道动态CCE占用率` float,
+MODIFY COLUMN `平均单Flow流量_MB` float;
+
+UPDATE 4G SET `日期` = DATE_FORMAT(`日期时间`, '%Y-%m-%d'), CGI = CONCAT("460-00-",eNodeBId,"-", cellLocalId);
+UPDATE 5G SET gNBplmn = "460-00" WHERE gNBplmn IS NULL;
+UPDATE 5G SET `日期` = DATE_FORMAT(`日期时间`, '%Y-%m-%d'), NCGI = CONCAT(gNBplmn, "-",gNBId,"-", cellLocalId);
+
+ALTER TABLE 4G
+ADD INDEX(`日期`),
+ADD INDEX(`日期时间`),
+ADD INDEX(`CGI`),
+ADD INDEX `TC`(`日期时间`, `CGI`),
+ADD INDEX `DC`(`日期`, `CGI`);
+
+ALTER TABLE 5G
+ADD INDEX(`日期`),
+ADD INDEX(`日期时间`),
+ADD INDEX(`NCGI`),
+ADD INDEX `TC`(`日期时间`, `NCGI`),
+ADD INDEX `DC`(`日期`, `NCGI`);
+
+
+CREATE TEMPORARY TABLE IF NOT EXISTS `CCE_MAX_IDX`(
+	SELECT
+		`日期`,
+		CGI,
+		MAX( `PDCCH资源利用率`) AS `PDCCH资源利用率_忙时`
+	FROM 4G
+	GROUP BY `日期`, CGI
+);
+
+ALTER TABLE `CCE_MAX_IDX`
+ADD COLUMN `日期时间` datetime,
+ADD INDEX `DC`(`日期`, `CGI`, `PDCCH资源利用率_忙时`),
+ADD INDEX `TC`(`日期时间`, `CGI`);
+
+UPDATE `CCE_MAX_IDX` INNER JOIN 4G
+ON
+	`CCE_MAX_IDX`.`日期` = 4G.`日期` AND
+	`CCE_MAX_IDX`.CGI=4G.CGI AND
+	`CCE_MAX_IDX`.`PDCCH资源利用率_忙时`=4G.`PDCCH资源利用率`
+SET
+	`CCE_MAX_IDX`.`日期时间`=4G.`日期时间`;
+
+
+CREATE TEMPORARY TABLE IF NOT EXISTS `CCE_MAX` (
+	SELECT 4G.*
+	FROM `CCE_MAX_IDX` LEFT JOIN 4G
+	ON `CCE_MAX_IDX`.CGI=4G.CGI AND
+		`CCE_MAX_IDX`.`日期时间`=4G.`日期时间`
+);
+
+DROP TABLE IF EXISTS `CCE_MAX_IDX`;
+
+CREATE TEMPORARY TABLE IF NOT EXISTS `ULPRB_MAX_IDX`(
+	SELECT
+		`日期`,
+		CGI,
+		MAX( `上行PUSCH利用率`) AS `上行PUSCH利用率_忙时`
+	FROM 4G
+	GROUP BY `日期`, CGI
+);
+
+ALTER TABLE `ULPRB_MAX_IDX`
+ADD COLUMN `日期时间` datetime,
+ADD INDEX `DC`(`日期`, `CGI`, `上行PUSCH利用率_忙时`),
+ADD INDEX `TC`(`日期时间`, `CGI`);
+
+UPDATE `ULPRB_MAX_IDX` INNER JOIN 4G
+ON
+	`ULPRB_MAX_IDX`.`日期` = 4G.`日期` AND
+	`ULPRB_MAX_IDX`.CGI=4G.CGI AND
+	`ULPRB_MAX_IDX`.`上行PUSCH利用率_忙时`=4G.`上行PUSCH利用率`
+SET
+	`ULPRB_MAX_IDX`.`日期时间`=4G.`日期时间`;
+
+CREATE TABLE IF NOT EXISTS `ULPRB_MAX` (
+	SELECT 4G.*
+	FROM `ULPRB_MAX_IDX` LEFT JOIN 4G
+	ON `ULPRB_MAX_IDX`.CGI=4G.CGI AND
+		`ULPRB_MAX_IDX`.`日期时间`=4G.`日期时间`
+);
+
+DROP TABLE IF EXISTS `ULPRB_MAX_IDX`;
+
+CREATE TEMPORARY TABLE IF NOT EXISTS `DLPRB_MAX_IDX`(
+	SELECT
+		`日期`,
+		CGI,
+		MAX( `下行PDSCH利用率`) AS `下行PDSCH利用率_忙时`
+	FROM 4G
+	GROUP BY `日期`, CGI
+);
+
+ALTER TABLE `DLPRB_MAX_IDX`
+ADD COLUMN `日期时间` datetime,
+ADD INDEX `DC`(`日期`, `CGI`, `下行PDSCH利用率_忙时`),
+ADD INDEX `TC`(`日期时间`, `CGI`);
+
+UPDATE `DLPRB_MAX_IDX` INNER JOIN 4G
+ON
+	`DLPRB_MAX_IDX`.`日期` = 4G.`日期` AND
+	`DLPRB_MAX_IDX`.CGI=4G.CGI AND
+	`DLPRB_MAX_IDX`.`下行PDSCH利用率_忙时`=4G.`下行PDSCH利用率`
+SET
+	`DLPRB_MAX_IDX`.`日期时间`=4G.`日期时间`;
+
+CREATE TEMPORARY TABLE IF NOT EXISTS `DLPRB_MAX` (
+	SELECT 4G.*
+	FROM `DLPRB_MAX_IDX` LEFT JOIN 4G
+	ON `DLPRB_MAX_IDX`.CGI=4G.CGI AND
+		`DLPRB_MAX_IDX`.`日期时间`=4G.`日期时间`
+);
+
+DROP TABLE IF EXISTS `DLPRB_MAX_IDX`;
+
+ALTER TABLE `CCE_MAX` ADD INDEX `DC`(`日期`, `CGI`);
+ALTER TABLE `DLPRB_MAX` ADD INDEX `DC`(`日期`, `CGI`);
+ALTER TABLE `ULPRB_MAX` ADD INDEX `DC`(`日期`, `CGI`);
+
+
+
+CREATE TEMPORARY TABLE IF NOT EXISTS `4G_Date` (
+	SELECT `日期`, CGI FROM 4G GROUP BY `日期`, CGI
+);
+ALTER TABLE `4G_Date` ADD INDEX `DC`(`日期`, CGI);
+
+
+CREATE TEMPORARY TABLE IF NOT EXISTS `4G_MAX_IDX` (
+	SELECT
+		4G_Date.`日期`,
+		4G_Date.CGI,
+		GREATEST(`ULPRB_MAX`.`上行PUSCH利用率`, DLPRB_MAX.`下行PDSCH利用率`,CCE_MAX.`PDCCH资源利用率`) AS `最大值`
+	FROM
+		4G_Date
+	INNER JOIN
+		DLPRB_MAX
+	ON
+		4G_Date.`日期` = DLPRB_MAX.`日期` AND
+		4G_Date.CGI = DLPRB_MAX.CGI
+	INNER JOIN
+		CCE_MAX
+	ON
+		4G_Date.`日期` = CCE_MAX.`日期` AND
+		4G_Date.CGI = CCE_MAX.CGI
+	INNER JOIN
+		ULPRB_MAX
+	ON
+		4G_Date.`日期` = ULPRB_MAX.`日期` AND
+		4G_Date.CGI = ULPRB_MAX.CGI
+);
+DROP TABLE IF EXISTS `4G_Date`;
+ALTER TABLE `4G_MAX_IDX` ADD INDEX `DC`(`日期`, CGI), ADD INDEX (`最大值`);
+
+CREATE TABLE IF NOT EXISTS `4G_MAX` (
+	SELECT * FROM 4G LIMIT 0
+);
+
+
+ALTER TABLE `4G_MAX` ADD INDEX (`日期`), ADD INDEX (`CGI`), ADD INDEX `DC` (`日期`,CGI), ADD INDEX `idx`(`CGI`, `基站名称`, `小区名称`);
+
+ALTER TABLE DLPRB_MAX ADD COLUMN `insert` INT NOT NULL DEFAULT 0;
+ALTER TABLE CCE_MAX ADD COLUMN `insert` INT NOT NULL DEFAULT 0;
+
+
+
+
+TRUNCATE `4G_MAX`;
+INSERT INTO `4G_MAX`
+	SELECT ULPRB_MAX.* FROM ULPRB_MAX INNER JOIN `4G_MAX_IDX`
+	ON
+		ULPRB_MAX.`日期`  = 4G_MAX_IDX.`日期` AND
+		ULPRB_MAX.CGI = 4G_MAX_IDX.`CGI` AND
+		ULPRB_MAX.`上行PUSCH利用率` = 4G_MAX_IDX.`最大值`;
+
+UPDATE DLPRB_MAX INNER JOIN 4G_MAX ON DLPRB_MAX.`日期` = 4G_MAX.`日期` AND DLPRB_MAX.CGI = 4G_MAX.CGI SET DLPRB_MAX.`insert` = 1;
+ALTER TABLE DLPRB_MAX ADD INDEX (`insert`);
+DELETE FROM DLPRB_MAX WHERE `insert` = 1;
+ALTER TABLE DLPRB_MAX DROP COLUMN `insert`;
+INSERT INTO `4G_MAX`
+	SELECT DLPRB_MAX.* FROM DLPRB_MAX INNER JOIN `4G_MAX_IDX`
+	ON
+		DLPRB_MAX.`日期`  = 4G_MAX_IDX.`日期` AND
+		DLPRB_MAX.CGI = 4G_MAX_IDX.`CGI` AND
+		DLPRB_MAX.`下行PDSCH利用率` = 4G_MAX_IDX.`最大值`;
+
+UPDATE CCE_MAX INNER JOIN 4G_MAX ON CCE_MAX.`日期` = 4G_MAX.`日期` AND CCE_MAX.CGI = 4G_MAX.CGI SET CCE_MAX.`insert` = 1;
+ALTER TABLE CCE_MAX ADD INDEX (`insert`);
+DELETE FROM CCE_MAX WHERE `insert` = 1;
+ALTER TABLE CCE_MAX DROP COLUMN `insert`;
+INSERT INTO `4G_MAX`
+	SELECT CCE_MAX.* FROM CCE_MAX INNER JOIN `4G_MAX_IDX`
+	ON
+		CCE_MAX.`日期`  = 4G_MAX_IDX.`日期` AND
+		CCE_MAX.CGI = 4G_MAX_IDX.`CGI` AND
+		CCE_MAX.`PDCCH资源利用率` = 4G_MAX_IDX.`最大值`;
+
+
+DROP TABLE IF EXISTS `CCE_MAX`;
+DROP TABLE IF EXISTS `ULPRB_MAX`;
+DROP TABLE IF EXISTS `DLPRB_MAX`;
+DROP TABLE IF EXISTS `4G_MAX_IDX`;
+
+CREATE TEMPORARY TABLE IF NOT EXISTS `日流量`(SELECT `日期`,CGI, SUM(`上下行总流量_GB`) AS `日流量` FROM 4G GROUP BY `日期`,CGI);
+ALTER TABLE `日流量` ADD INDEX (`CGI`);
+DROP TABLE IF EXISTS `4G日均流量`;
+CREATE TEMPORARY TABLE IF NOT EXISTS `4G日均流量` (
+	SELECT CGI, AVG(`日流量`) AS `日均流量`, COUNT(`日期`) AS `流量有效天数` FROM `日流量` WHERE `日流量` > 0 GROUP BY CGI
+);
+
+
+
+
+CREATE TABLE IF NOT EXISTS `4G_结果表` (
+	SELECT CGI, `基站名称`, `小区名称`,
+		ROUND(AVG(`上下行总流量_GB`),6) AS `自忙时流量（GB）`,
+		ROUND(AVG(`ERAB流量`),6) AS `ERAB流量`,
+		ROUND(AVG(`上行流量_GB`),6) AS `上行流量（GB）`,
+		ROUND(AVG(`下行流量_GB`),6) AS `下行流量（GB）`,
+		ROUND(AVG(`用户面平均激活UE数`),6) AS `用户面平均激活UE数`,
+		ROUND(AVG(`RRC连接建立最大用户数`),6) AS `YY-RRC连接建立最大用户数`,
+		ROUND(AVG(`上行PUSCH利用率`) / 100,6) AS `上行PUSCH利用率`,
+		ROUND(AVG(`下行PDSCH利用率`) / 100,6) AS `下行PDSCH利用率`,
+		ROUND(AVG(`PDCCH资源利用率`) / 100,6) AS `PDCCH资源利用率`,
+		ROUND(AVG(`用户面最大激活UE数`),6) AS `用户面最大激活UE数`
+	FROM 4G_MAX GROUP BY CGI, `基站名称`, `小区名称`
+);
+DROP TABLE IF EXISTS `4G_MAX`;
+ALTER TABLE `4G_结果表` ADD COLUMN `日均流量（GB）` DOUBLE AFTER `小区名称`, ADD INDEX (`CGI`);
+ALTER TABLE `4G日均流量` ADD INDEX (CGI);
+UPDATE `4G_结果表` INNER JOIN `4G日均流量`
+ON `4G_结果表`.CGI=`4G日均流量`.CGI
+SET `4G_结果表`.`日均流量（GB）` = ROUND(`4G日均流量`.`日均流量`,6);
+
+DROP TABLE IF EXISTS `日流量`;
+DROP TABLE IF EXISTS `4G日均流量`;
+DROP TABLE IF EXISTS `4G`;
+
+
+# 5G脚本
+
+CREATE TEMPORARY TABLE IF NOT EXISTS `ULPRB_MAX_IDX`(
+	SELECT
+		`日期`,
+		NCGI,
+		MAX(`上行PRB平均利用率`) AS `上行PRB平均利用率_忙时`
+	FROM 5G
+	GROUP BY `日期`, NCGI
+);
+
+ALTER TABLE `ULPRB_MAX_IDX`
+ADD COLUMN `日期时间` datetime,
+ADD INDEX `DC`(`日期`, `NCGI`, `上行PRB平均利用率_忙时`),
+ADD INDEX `TC`(`日期时间`, `NCGI`);
+
+UPDATE `ULPRB_MAX_IDX` INNER JOIN 5G
+ON
+	`ULPRB_MAX_IDX`.`日期` = 5G.`日期` AND
+	`ULPRB_MAX_IDX`.NCGI=5G.NCGI AND
+	`ULPRB_MAX_IDX`.`上行PRB平均利用率_忙时`=5G.`上行PRB平均利用率`
+SET
+	`ULPRB_MAX_IDX`.`日期时间`=5G.`日期时间`;
+
+CREATE TEMPORARY TABLE IF NOT EXISTS `ULPRB_MAX` (
+	SELECT 5G.*
+	FROM `ULPRB_MAX_IDX` LEFT JOIN 5G
+	ON `ULPRB_MAX_IDX`.NCGI=5G.NCGI AND
+		`ULPRB_MAX_IDX`.`日期时间`=5G.`日期时间`
+);
+
+# 下行PRB MAX表
+CREATE TEMPORARY TABLE IF NOT EXISTS `DLPRB_MAX_IDX`(
+	SELECT
+		`日期`,
+		NCGI,
+		MAX( `下行PRB平均利用率`) AS `下行PRB平均利用率_忙时`
+	FROM 5G
+	GROUP BY `日期`, NCGI
+);
+
+ALTER TABLE `DLPRB_MAX_IDX`
+ADD COLUMN `日期时间` datetime,
+ADD INDEX `DC`(`日期`, `NCGI`, `下行PRB平均利用率_忙时`),
+ADD INDEX `TC`(`日期时间`, `NCGI`);
+
+UPDATE `DLPRB_MAX_IDX` INNER JOIN 5G
+ON
+	`DLPRB_MAX_IDX`.`日期` = 5G.`日期` AND
+	`DLPRB_MAX_IDX`.NCGI=5G.NCGI AND
+	`DLPRB_MAX_IDX`.`下行PRB平均利用率_忙时`=5G.`下行PRB平均利用率`
+SET
+	`DLPRB_MAX_IDX`.`日期时间`=5G.`日期时间`;
+
+CREATE TEMPORARY TABLE IF NOT EXISTS `DLPRB_MAX` (
+	SELECT 5G.*
+	FROM `DLPRB_MAX_IDX` LEFT JOIN 5G
+	ON `DLPRB_MAX_IDX`.NCGI=5G.NCGI AND
+		`DLPRB_MAX_IDX`.`日期时间`=5G.`日期时间`
+);
+
+DROP TABLE IF EXISTS `DLPRB_MAX_IDX`;
+ALTER TABLE `DLPRB_MAX` ADD INDEX `DC`(`日期`, `NCGI`);
+ALTER TABLE `ULPRB_MAX` ADD INDEX `DC`(`日期`, `NCGI`);
+
+# 5G 统计MAX数据
+
+DROP TABLE IF EXISTS `5G_Date`;
+CREATE TEMPORARY TABLE IF NOT EXISTS `5G_Date` (
+	SELECT `日期`, NCGI FROM 5G GROUP BY `日期`, NCGI
+);
+ALTER TABLE `5G_Date` ADD INDEX `DC`(`日期`, NCGI);
+
+CREATE TEMPORARY TABLE IF NOT EXISTS `5G_MAX_IDX` (
+	SELECT
+		5G_Date.`日期`,
+		5G_Date.NCGI,
+		GREATEST(ULPRB_MAX.`上行PRB平均利用率`, DLPRB_MAX.`下行PRB平均利用率`) AS `最大值`
+	FROM
+		5G_Date
+	INNER JOIN
+		DLPRB_MAX
+	ON
+		5G_Date.`日期` = DLPRB_MAX.`日期` AND
+		5G_Date.NCGI = DLPRB_MAX.NCGI
+	INNER JOIN
+		ULPRB_MAX
+	ON
+		5G_Date.`日期` = ULPRB_MAX.`日期` AND
+		5G_Date.NCGI = ULPRB_MAX.NCGI
+);
+
+DROP TABLE IF EXISTS `5G_Date`;
+ALTER TABLE `5G_MAX_IDX` ADD INDEX `DC`(`日期`, NCGI), ADD INDEX (`最大值`);
+
+
+CREATE TABLE IF NOT EXISTS `5G_MAX` (
+	SELECT * FROM 5G LIMIT 0
+);
+
+
+ALTER TABLE `5G_MAX` ADD INDEX (`日期`), ADD INDEX (`NCGI`), ADD INDEX `DC` (`日期`,NCGI), ADD INDEX `idx`(`NCGI`, `CU小区配置名称`);
+
+ALTER TABLE DLPRB_MAX ADD COLUMN `insert` INT NOT NULL DEFAULT 0;
+TRUNCATE `5G_MAX`;
+INSERT INTO `5G_MAX`
+	SELECT ULPRB_MAX.* FROM ULPRB_MAX INNER JOIN `5G_MAX_IDX`
+	ON
+		ULPRB_MAX.`日期` = 5G_MAX_IDX.`日期` AND
+		ULPRB_MAX.NCGI = 5G_MAX_IDX.`NCGI` AND
+		ULPRB_MAX.`上行PRB平均利用率` = 5G_MAX_IDX.`最大值`;
+
+UPDATE DLPRB_MAX INNER JOIN 5G_MAX ON DLPRB_MAX.`日期` = 5G_MAX.`日期` AND DLPRB_MAX.NCGI = 5G_MAX.NCGI SET DLPRB_MAX.`insert` = 1;
+ALTER TABLE DLPRB_MAX ADD INDEX (`insert`);
+DELETE FROM DLPRB_MAX WHERE `insert` = 1;
+ALTER TABLE DLPRB_MAX DROP COLUMN `insert`;
+INSERT INTO `5G_MAX`
+	SELECT DLPRB_MAX.* FROM DLPRB_MAX INNER JOIN `5G_MAX_IDX`
+	ON
+		DLPRB_MAX.`日期` = 5G_MAX_IDX.`日期` AND
+		DLPRB_MAX.NCGI = 5G_MAX_IDX.`NCGI` AND
+		DLPRB_MAX.`下行PRB平均利用率` = 5G_MAX_IDX.`最大值`;
+
+DROP TABLE IF EXISTS `ULPRB_MAX`;
+DROP TABLE IF EXISTS `DLPRB_MAX`;
+DROP TABLE IF EXISTS `5G_MAX_IDX`;
+
+CREATE TEMPORARY TABLE IF NOT EXISTS `日流量`(SELECT `日期`,NCGI, SUM(`5G上下行总流量_GB`) AS `日流量` FROM 5G GROUP BY `日期`,NCGI);
+ALTER TABLE `日流量` ADD INDEX (`NCGI`);
+CREATE TEMPORARY TABLE IF NOT EXISTS `5G日均流量` (
+	SELECT NCGI, AVG(`日流量`) AS `日均流量`, COUNT(`日期`) AS `流量有效天数` FROM `日流量` WHERE `日流量` > 0 GROUP BY NCGI
+);
+
+CREATE TABLE IF NOT EXISTS `5G_结果表` (
+	SELECT NCGI, `CU小区配置名称`,
+		ROUND(AVG(`5G上下行总流量_GB`),6) AS `5G上下行总流量（上行PDCP PDU数据量+下行PDCP成功发送数据量）(GB)`,
+		ROUND(AVG(`5G上行流量_GB`),6) AS `5G上行流量（上行PDCP PDU数据量）(GB)`,
+		ROUND(AVG(`5G下行流量_GB`),6) AS `5G下行流量（下行PDCP成功发送数据量）(GB)`,
+		ROUND(AVG(`小区平均激活UE数`),6) AS `小区平均激活UE数`,
+		ROUND(AVG(`RRC连接最大连接用户数`),6) AS `RRC连接最大连接用户数`,
+		ROUND(AVG(`RRC连接平均连接用户数`),6) AS `RRC连接平均连接用户数`,
+		ROUND(AVG(`小区最大激活UE数`),6) AS `小区最大激活UE数`,
+		ROUND(AVG(`上行PRB平均利用率`) / 100,6) AS `上行PRB平均利用率`,
+		ROUND(AVG(`下行PRB平均利用率`) / 100,6) AS `下行PRB平均利用率`,
+		ROUND(AVG(`PDCCH信道动态CCE占用率`) / 100,6) AS `PDCCH信道CCE占用率（动态）(%)`,
+		ROUND(AVG(`小区下行RLC_SDU字节数_MByte`),6) AS `小区下行RLC SDU字节数(MByte)`,
+		ROUND(AVG(`小区上行RLC_SDU字节数_MByte`),6) AS `小区上行RLC SDU字节数(MByte)`,
+		ROUND(AVG(`平均单Flow流量_MB`),6) AS `单Flow流量(MB)`
+	FROM 5G_MAX GROUP BY NCGI, `CU小区配置名称`
+);
+
+ALTER TABLE `5G_结果表` ADD COLUMN `日均流量（GB）` DOUBLE AFTER `CU小区配置名称`, ADD INDEX (`NCGI`);
+ALTER TABLE `5G日均流量` ADD INDEX (NCGI);
+UPDATE `5G_结果表` INNER JOIN `5G日均流量`
+ON `5G_结果表`.NCGI=`5G日均流量`.NCGI
+SET `5G_结果表`.`日均流量（GB）` = ROUND(`5G日均流量`.`日均流量`,6);
+
+DROP TABLE IF EXISTS `日流量`;
+DROP TABLE IF EXISTS `5G日均流量`;
+DROP TABLE IF EXISTS `4G`;
+DROP TABLE IF EXISTS `5G`;
\ No newline at end of file
diff --git a/app/config.py b/app/config.py
new file mode 100644
index 0000000..05bbfbe
--- /dev/null
+++ b/app/config.py
@@ -0,0 +1,109 @@
+"""
+配置管理模块
+"""
+import json
+from pathlib import Path
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+from dataclasses import dataclass, field
+
+
+BASE_DIR = Path(__file__).resolve().parent.parent
+CACHE_DIR = BASE_DIR / "cache"
+CONFIG_FILE = BASE_DIR / "Configure.json"
+SQL_SCRIPT = BASE_DIR / "ReportScript.sql"
+
+
+@dataclass
+class MySQLConfig:
+    host: str = "localhost"
+    port: int = 3306
+    user: str = "root"
+    passwd: str = ""
+    dbname: str = "CapacityReport"
+
+
+@dataclass
+class AppConfig:
+    update: str = ""
+    mysql: MySQLConfig = field(default_factory=MySQLConfig)
+    sheet_filter: List[str] = field(default_factory=list)
+    extract_fields: List[Dict[str, Any]] = field(default_factory=list)
+
+    @classmethod
+    def load(cls) -> "AppConfig":
+        """从 Configure.json 加载配置"""
+        if not CONFIG_FILE.exists():
+            return cls()
+        
+        with open(CONFIG_FILE, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        
+        mysql_data = data.get("MySQL_DBInfo", {})
+        mysql_config = MySQLConfig(
+            host=mysql_data.get("host", "localhost"),
+            port=mysql_data.get("port", 3306),
+            user=mysql_data.get("user", "root"),
+            passwd=mysql_data.get("passwd", ""),
+            dbname=mysql_data.get("dbname", "CapacityReport")
+        )
+        
+        return cls(
+            update=data.get("Update", ""),
+            mysql=mysql_config,
+            sheet_filter=data.get("SheetFilter", []),
+            extract_fields=data.get("ExtractField", [])
+        )
+    
+    def save(self):
+        """保存配置到 Configure.json，并自动更新 Update 时间"""
+        self.update = datetime.now().strftime("%Y/%m/%d %H:%M:%S")
+        
+        data = {
+            "Update": self.update,
+            "MySQL_DBInfo": {
+                "host": self.mysql.host,
+                "port": self.mysql.port,
+                "user": self.mysql.user,
+                "passwd": self.mysql.passwd,
+                "dbname": self.mysql.dbname
+            },
+            "SheetFilter": self.sheet_filter,
+            "ExtractField": self.extract_fields
+        }
+        
+        with open(CONFIG_FILE, 'w', encoding='utf-8') as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """转换为字典（用于返回给前端，隐藏密码）"""
+        return {
+            "update": self.update,
+            "mysql": {
+                "host": self.mysql.host,
+                "port": self.mysql.port,
+                "user": self.mysql.user,
+                "dbname": self.mysql.dbname
+            },
+            "sheet_filter": self.sheet_filter,
+            "extract_fields": self.extract_fields
+        }
+    
+    def to_dict_full(self) -> Dict[str, Any]:
+        """转换为完整字典（包含密码，用于编辑时回显）"""
+        return {
+            "update": self.update,
+            "mysql": {
+                "host": self.mysql.host,
+                "port": self.mysql.port,
+                "user": self.mysql.user,
+                "passwd": self.mysql.passwd,
+                "dbname": self.mysql.dbname
+            },
+            "sheet_filter": self.sheet_filter,
+            "extract_fields": self.extract_fields
+        }
+
+
+# 确保缓存目录存在
+CACHE_DIR.mkdir(exist_ok=True)
diff --git a/app/database.py b/app/database.py
new file mode 100644
index 0000000..a83ab80
--- /dev/null
+++ b/app/database.py
@@ -0,0 +1,262 @@
+"""
+数据库连接与操作模块 - 性能优化版
+"""
+import pymysql
+import sqlalchemy
+from sqlalchemy import create_engine, text, event
+from sqlalchemy.pool import QueuePool
+from urllib.parse import quote
+from typing import Any, Dict, List, Optional, Tuple
+from contextlib import contextmanager
+
+from app.config import AppConfig
+
+
+class DatabaseManager:
+    """数据库管理器 - 高性能版"""
+    
+    def __init__(self, config: AppConfig):
+        self.config = config
+        self._engine: Optional[sqlalchemy.Engine] = None
+    
+    @property
+    def engine(self) -> sqlalchemy.Engine:
+        """获取 SQLAlchemy 引擎（带连接池）- 优化配置"""
+        if self._engine is None:
+            mysql = self.config.mysql
+            self._engine = create_engine(
+                f'mysql+pymysql://'
+                f'{quote(mysql.user)}:'
+                f'{quote(mysql.passwd)}@'
+                f'{quote(mysql.host)}:'
+                f'{mysql.port}/'
+                f'{quote(mysql.dbname)}?charset=utf8mb4',
+                poolclass=QueuePool,
+                pool_size=10,           # 增大连接池
+                max_overflow=20,        # 增大溢出连接
+                pool_pre_ping=True,
+                pool_recycle=3600,
+                echo=False,
+                # 性能优化参数
+                connect_args={
+                    'local_infile': True,   # 允许 LOAD DATA LOCAL
+                    'autocommit': False,
+                }
+            )
+        return self._engine
+    
+    @contextmanager
+    def get_connection(self):
+        """获取 PyMySQL 连接（上下文管理器）"""
+        mysql = self.config.mysql
+        conn = pymysql.connect(
+            host=mysql.host,
+            port=mysql.port,
+            user=mysql.user,
+            password=mysql.passwd,
+            database=mysql.dbname,
+            charset='utf8mb4',
+            cursorclass=pymysql.cursors.DictCursor,
+            local_infile=True,          # 允许 LOAD DATA LOCAL
+            autocommit=False
+        )
+        try:
+            yield conn
+        finally:
+            conn.close()
+    
+    @contextmanager
+    def get_fast_connection(self):
+        """获取高性能 PyMySQL 连接（用于批量插入）"""
+        mysql = self.config.mysql
+        conn = pymysql.connect(
+            host=mysql.host,
+            port=mysql.port,
+            user=mysql.user,
+            password=mysql.passwd,
+            database=mysql.dbname,
+            charset='utf8mb4',
+            cursorclass=pymysql.cursors.Cursor,  # 使用普通游标更快
+            local_infile=True,
+            autocommit=False,
+            read_timeout=300,
+            write_timeout=300
+        )
+        try:
+            yield conn
+        finally:
+            conn.close()
+    
+    def test_connection(self) -> Tuple[bool, str]:
+        """测试数据库连接"""
+        try:
+            with self.get_connection() as conn:
+                with conn.cursor() as cursor:
+                    cursor.execute("SELECT 1")
+            return True, "连接成功"
+        except Exception as e:
+            return False, str(e)
+    
+    def get_tables(self) -> List[str]:
+        """获取所有表名"""
+        with self.get_connection() as conn:
+            with conn.cursor() as cursor:
+                cursor.execute("SHOW TABLES")
+                return [list(row.values())[0] for row in cursor.fetchall()]
+    
+    def get_table_info(self, table_name: str) -> Dict[str, Any]:
+        """获取表信息"""
+        with self.get_connection() as conn:
+            with conn.cursor() as cursor:
+                # 获取列信息
+                cursor.execute(f"DESCRIBE `{table_name}`")
+                columns = cursor.fetchall()
+                
+                # 获取行数
+                cursor.execute(f"SELECT COUNT(*) as count FROM `{table_name}`")
+                count = cursor.fetchone()['count']
+                
+                return {
+                    "name": table_name,
+                    "columns": columns,
+                    "row_count": count
+                }
+    
+    def query_table(
+        self, 
+        table_name: str, 
+        page: int = 1, 
+        page_size: int = 50,
+        filters: Optional[Dict[str, str]] = None,
+        order_by: Optional[str] = None,
+        order_dir: str = "ASC"
+    ) -> Dict[str, Any]:
+        """分页查询表数据"""
+        offset = (page - 1) * page_size
+        
+        with self.get_connection() as conn:
+            with conn.cursor() as cursor:
+                # 构建 WHERE 条件
+                where_clause = ""
+                params = []
+                if filters:
+                    conditions = []
+                    for col, val in filters.items():
+                        if val:
+                            conditions.append(f"`{col}` LIKE %s")
+                            params.append(f"%{val}%")
+                    if conditions:
+                        where_clause = "WHERE " + " AND ".join(conditions)
+                
+                # 获取总数
+                count_sql = f"SELECT COUNT(*) as count FROM `{table_name}` {where_clause}"
+                cursor.execute(count_sql, params)
+                total = cursor.fetchone()['count']
+                
+                # 构建排序
+                order_clause = ""
+                if order_by:
+                    order_clause = f"ORDER BY `{order_by}` {order_dir}"
+                
+                # 查询数据
+                query_sql = f"SELECT * FROM `{table_name}` {where_clause} {order_clause} LIMIT %s OFFSET %s"
+                cursor.execute(query_sql, params + [page_size, offset])
+                rows = cursor.fetchall()
+                
+                return {
+                    "data": rows,
+                    "total": total,
+                    "page": page,
+                    "page_size": page_size,
+                    "total_pages": (total + page_size - 1) // page_size
+                }
+    
+    def delete_rows(self, table_name: str, condition: str, params: List[Any]) -> int:
+        """删除符合条件的行"""
+        with self.get_connection() as conn:
+            with conn.cursor() as cursor:
+                sql = f"DELETE FROM `{table_name}` WHERE {condition}"
+                cursor.execute(sql, params)
+                conn.commit()
+                return cursor.rowcount
+    
+    def truncate_table(self, table_name: str) -> bool:
+        """清空表"""
+        with self.get_connection() as conn:
+            with conn.cursor() as cursor:
+                cursor.execute(f"TRUNCATE TABLE `{table_name}`")
+                conn.commit()
+                return True
+    
+    def drop_table(self, table_name: str) -> bool:
+        """删除表"""
+        with self.get_connection() as conn:
+            with conn.cursor() as cursor:
+                cursor.execute(f"DROP TABLE IF EXISTS `{table_name}`")
+                conn.commit()
+                return True
+    
+    def execute_sql(self, sql: str) -> Tuple[bool, Any]:
+        """执行自定义 SQL"""
+        with self.get_connection() as conn:
+            with conn.cursor() as cursor:
+                try:
+                    cursor.execute(sql)
+                    if sql.strip().upper().startswith("SELECT"):
+                        return True, cursor.fetchall()
+                    else:
+                        conn.commit()
+                        return True, {"affected_rows": cursor.rowcount}
+                except Exception as e:
+                    return False, str(e)
+    
+    def bulk_insert(self, table_name: str, columns: List[str], data: List[Tuple], 
+                    batch_size: int = 5000) -> int:
+        """
+        高性能批量插入
+        使用 executemany + 批量提交，比 to_sql 快 5-10 倍
+        """
+        if not data:
+            return 0
+        
+        total_inserted = 0
+        placeholders = ', '.join(['%s'] * len(columns))
+        column_names = ', '.join([f'`{col}`' for col in columns])
+        sql = f"INSERT INTO `{table_name}` ({column_names}) VALUES ({placeholders})"
+        
+        with self.get_fast_connection() as conn:
+            with conn.cursor() as cursor:
+                # 优化插入性能的设置
+                cursor.execute("SET autocommit=0")
+                cursor.execute("SET unique_checks=0")
+                cursor.execute("SET foreign_key_checks=0")
+                
+                # 分批插入
+                for i in range(0, len(data), batch_size):
+                    batch = data[i:i + batch_size]
+                    cursor.executemany(sql, batch)
+                    total_inserted += len(batch)
+                
+                # 提交并恢复设置
+                conn.commit()
+                cursor.execute("SET unique_checks=1")
+                cursor.execute("SET foreign_key_checks=1")
+                cursor.execute("SET autocommit=1")
+        
+        return total_inserted
+    
+    def create_table_from_columns(self, table_name: str, columns: List[str]):
+        """根据列名创建表（所有列都是 VARCHAR(255)）"""
+        column_defs = ', '.join([f'`{col}` VARCHAR(255)' for col in columns])
+        sql = f"CREATE TABLE IF NOT EXISTS `{table_name}` ({column_defs}) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4"
+        
+        with self.get_connection() as conn:
+            with conn.cursor() as cursor:
+                cursor.execute(sql)
+                conn.commit()
+    
+    def dispose(self):
+        """释放连接池"""
+        if self._engine:
+            self._engine.dispose()
+            self._engine = None
diff --git a/app/history.py b/app/history.py
new file mode 100644
index 0000000..d826de2
--- /dev/null
+++ b/app/history.py
@@ -0,0 +1,221 @@
+"""
+处理历史记录管理模块
+"""
+import json
+import shutil
+from pathlib import Path
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+from dataclasses import dataclass, field, asdict
+
+from app.config import CACHE_DIR
+
+
+HISTORY_FILE = CACHE_DIR / "history.json"
+
+
+@dataclass
+class HistoryRecord:
+    """历史记录"""
+    id: str
+    timestamp: str
+    status: str  # pending, processing, completed, failed
+    work_dir: str
+    file_count: int = 0
+    elapsed_time: float = 0.0
+    error: Optional[str] = None
+    result_tables: List[str] = field(default_factory=list)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+    
+    def get_log_file(self) -> Path:
+        """获取日志文件路径"""
+        return Path(self.work_dir) / "log.txt"
+
+
+class HistoryManager:
+    """历史记录管理器"""
+    
+    def __init__(self):
+        self._ensure_file()
+    
+    def _ensure_file(self):
+        """确保历史文件存在"""
+        if not HISTORY_FILE.exists():
+            HISTORY_FILE.write_text("[]", encoding='utf-8')
+    
+    def _load(self) -> List[Dict[str, Any]]:
+        """加载历史记录"""
+        try:
+            return json.loads(HISTORY_FILE.read_text(encoding='utf-8'))
+        except:
+            return []
+    
+    def _save(self, records: List[Dict[str, Any]]):
+        """保存历史记录"""
+        HISTORY_FILE.write_text(json.dumps(records, ensure_ascii=False, indent=2), encoding='utf-8')
+    
+    def create(self, work_dir: Path, file_count: int, record_id: Optional[str] = None) -> HistoryRecord:
+        """创建新的历史记录"""
+        # 如果提供了 record_id，使用它；否则生成新的
+        if record_id is None:
+            record_id = datetime.now().strftime("%Y%m%d_%H%M%S")
+        
+        record = HistoryRecord(
+            id=record_id,
+            timestamp=datetime.now().isoformat(),
+            status="pending",
+            work_dir=str(work_dir),
+            file_count=file_count
+        )
+        
+        records = self._load()
+        records.insert(0, record.to_dict())
+        
+        # 只保留最近 100 条记录
+        records = records[:100]
+        self._save(records)
+        
+        return record
+    
+    def _clean_record(self, rec: Dict[str, Any]) -> Dict[str, Any]:
+        """清理记录，移除不存在的字段（如旧的 logs 字段）"""
+        cleaned = {
+            'id': rec.get('id'),
+            'timestamp': rec.get('timestamp'),
+            'status': rec.get('status'),
+            'work_dir': rec.get('work_dir'),
+            'file_count': rec.get('file_count', 0),
+            'elapsed_time': rec.get('elapsed_time', 0.0),
+            'error': rec.get('error'),
+            'result_tables': rec.get('result_tables', [])
+        }
+        return cleaned
+    
+    def update(self, record_id: str, **kwargs) -> Optional[HistoryRecord]:
+        """更新历史记录"""
+        records = self._load()
+        
+        for i, rec in enumerate(records):
+            if rec['id'] == record_id:
+                rec.update(kwargs)
+                self._save(records)
+                cleaned = self._clean_record(rec)
+                return HistoryRecord(**cleaned)
+        
+        return None
+    
+    def get(self, record_id: str) -> Optional[HistoryRecord]:
+        """获取单条记录"""
+        records = self._load()
+        for rec in records:
+            if rec['id'] == record_id:
+                cleaned = self._clean_record(rec)
+                return HistoryRecord(**cleaned)
+        return None
+    
+    def list(self, limit: int = 50) -> List[Dict[str, Any]]:
+        """获取历史记录列表"""
+        records = self._load()
+        # 返回简化的列表（不包含日志）
+        result = []
+        for rec in records[:limit]:
+            item = rec.copy()
+            item.pop('logs', None)  # 列表不返回日志（兼容旧数据）
+            result.append(item)
+        return result
+    
+    def get_logs(self, record_id: str) -> List[str]:
+        """从 log.txt 文件读取日志"""
+        record = self.get(record_id)
+        if not record:
+            return []
+        
+        log_file = record.get_log_file()
+        if not log_file.exists():
+            return []
+        
+        try:
+            content = log_file.read_text(encoding='utf-8')
+            # 按行分割，过滤空行
+            logs = [line.strip() for line in content.split('\n') if line.strip()]
+            return logs
+        except Exception as e:
+            print(f"读取日志文件失败: {log_file}, 错误: {e}")
+            return []
+    
+    def delete(self, record_id: str) -> bool:
+        """删除历史记录，同时删除对应的文件目录"""
+        records = self._load()
+        
+        # 找到要删除的记录，获取其工作目录
+        work_dir = None
+        for rec in records:
+            if rec['id'] == record_id:
+                work_dir = rec.get('work_dir')
+                break
+        
+        # 删除记录
+        new_records = [r for r in records if r['id'] != record_id]
+        
+        if len(new_records) < len(records):
+            self._save(new_records)
+            
+            # 删除对应的文件目录（安全检查：确保路径在cache目录内）
+            if work_dir:
+                try:
+                    work_path = Path(work_dir).resolve()
+                    cache_path = CACHE_DIR.resolve()
+                    
+                    # 安全检查：确保要删除的目录在cache目录内
+                    if work_path.exists() and work_path.is_dir():
+                        # 检查路径是否在cache目录内
+                        try:
+                            work_path.relative_to(cache_path)
+                            # 路径安全，可以删除
+                            shutil.rmtree(work_path)
+                        except ValueError:
+                            # 路径不在cache目录内，跳过删除（安全保护）
+                            print(f"警告: 尝试删除cache目录外的文件: {work_dir}")
+                except Exception as e:
+                    # 记录错误但不影响删除历史记录的操作
+                    print(f"删除文件目录失败: {work_dir}, 错误: {e}")
+            
+            return True
+        return False
+    
+    def clear(self) -> int:
+        """清空所有历史记录，同时清空cache目录（保留history.json）"""
+        records = self._load()
+        count = len(records)
+        
+        # 清空历史记录
+        self._save([])
+        
+        # 清空cache目录（保留history.json文件）
+        try:
+            cache_path = CACHE_DIR.resolve()
+            for item in CACHE_DIR.iterdir():
+                try:
+                    item_path = item.resolve()
+                    # 安全检查：确保路径在cache目录内
+                    item_path.relative_to(cache_path)
+                    
+                    if item.is_dir():
+                        # 删除所有子目录
+                        shutil.rmtree(item_path)
+                    elif item.is_file() and item.name != "history.json":
+                        # 删除所有文件，但保留history.json
+                        item_path.unlink()
+                except ValueError:
+                    # 路径不在cache目录内，跳过（安全保护）
+                    print(f"警告: 跳过cache目录外的文件: {item}")
+                except Exception as e:
+                    # 单个文件/目录删除失败，继续处理其他文件
+                    print(f"删除失败: {item}, 错误: {e}")
+        except Exception as e:
+            # 记录错误但不影响清空历史记录的操作
+            print(f"清空cache目录失败: {e}")
+        
+        return count
diff --git a/app/main.py b/app/main.py
new file mode 100644
index 0000000..918a9f6
--- /dev/null
+++ b/app/main.py
@@ -0,0 +1,907 @@
+"""
+CapacityReport - 容量报表处理程序
+FastAPI 主入口
+"""
+import os
+import sys
+import signal
+import shutil
+import asyncio
+import subprocess
+import platform
+from pathlib import Path
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+from threading import Thread
+
+from fastapi import FastAPI, File, UploadFile, HTTPException, Query, Body
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import HTMLResponse, FileResponse
+from fastapi.middleware.cors import CORSMiddleware
+
+from app.config import AppConfig, CACHE_DIR, BASE_DIR
+from app.database import DatabaseManager
+from app.processor import DataProcessor, ProcessLogger
+from app.history import HistoryManager
+
+
+# 创建应用
+app = FastAPI(
+    title="CapacityReport",
+    description="容量报表数据处理系统",
+    version="2.0.0"
+)
+
+# CORS 配置
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# 静态文件
+STATIC_DIR = BASE_DIR / "static"
+if STATIC_DIR.exists():
+    app.mount("/static", StaticFiles(directory=str(STATIC_DIR)), name="static")
+
+# 全局状态
+config = AppConfig.load()
+history_manager = HistoryManager()
+processing_tasks: Dict[str, Dict[str, Any]] = {}
+
+# 全局任务锁定状态（上传中或处理中）
+global_task_lock: Dict[str, Any] = {
+    "locked": False,
+    "task_id": None,
+    "stage": None,  # "uploading" 或 "processing"
+    "started_at": None
+}
+
+
+# ==================== 页面路由 ====================
+
+@app.get("/", response_class=HTMLResponse)
+async def index():
+    """返回主页"""
+    index_file = STATIC_DIR / "index.html"
+    if index_file.exists():
+        return HTMLResponse(content=index_file.read_text(encoding='utf-8'))
+    return HTMLResponse(content="<h1>CapacityReport</h1><p>Static files not found.</p>")
+
+
+# ==================== 文件上传 API ====================
+
+# 存储进行中的上传任务
+upload_sessions: Dict[str, Dict[str, Any]] = {}
+
+
+@app.post("/api/upload/create")
+async def create_upload_session():
+    """
+    创建上传会话
+    返回 session_id，后续上传文件使用这个 ID
+    """
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    session_id = timestamp
+    work_dir = CACHE_DIR / timestamp
+    work_dir.mkdir(parents=True, exist_ok=True)
+    
+    upload_sessions[session_id] = {
+        "work_dir": work_dir,
+        "files": [],
+        "created_at": datetime.now().isoformat()
+    }
+    
+    return {
+        "success": True,
+        "session_id": session_id,
+        "work_dir": str(work_dir)
+    }
+
+
+@app.post("/api/upload")
+async def upload_files(
+    files: List[UploadFile] = File(...),
+    session_id: Optional[str] = None
+):
+    """
+    上传文件
+    支持多文件上传，会保持目录结构
+    如果提供 session_id，则追加到现有会话
+    上传前会检查并锁定全局任务状态
+    """
+    if not files:
+        raise HTTPException(status_code=400, detail="没有上传文件")
+    
+    is_new_session = False
+    # 检查全局锁定状态（如果是新会话）
+    if not session_id or session_id not in upload_sessions:
+        if global_task_lock["locked"]:
+            raise HTTPException(status_code=409, detail="已有任务在运行，请等待当前任务完成")
+        
+        # 创建新会话并立即锁定
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        session_id = timestamp
+        work_dir = CACHE_DIR / timestamp
+        work_dir.mkdir(parents=True, exist_ok=True)
+        
+        # 立即锁定全局任务
+        global_task_lock["locked"] = True
+        global_task_lock["task_id"] = session_id
+        global_task_lock["stage"] = "uploading"
+        global_task_lock["started_at"] = datetime.now().isoformat()
+        is_new_session = True
+        
+        upload_sessions[session_id] = {
+            "work_dir": work_dir,
+            "files": [],
+            "created_at": datetime.now().isoformat()
+        }
+        session = upload_sessions[session_id]
+    else:
+        # 使用现有会话（追加文件）
+        work_dir = upload_sessions[session_id]["work_dir"]
+        session = upload_sessions[session_id]
+        # 验证会话是否属于当前锁定的任务
+        if global_task_lock["locked"] and global_task_lock["task_id"] != session_id:
+            raise HTTPException(status_code=409, detail="已有其他任务在运行")
+    
+    try:
+        saved_files = []
+        for file in files:
+            # 保持目录结构
+            # 文件名可能包含路径，如 "4G/data.xlsx"
+            file_path = work_dir / file.filename
+            file_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            # 保存文件
+            content = await file.read()
+            file_path.write_bytes(content)
+            saved_files.append(file.filename)
+            session["files"].append(file.filename)
+        
+        # 创建或更新历史记录（使用 session_id 作为记录 ID）
+        record = history_manager.get(session_id)
+        if not record:
+            record = history_manager.create(work_dir, len(session["files"]), record_id=session_id)
+        else:
+            history_manager.update(session_id, file_count=len(session["files"]))
+        
+        return {
+            "success": True,
+            "task_id": session_id,
+            "session_id": session_id,
+            "work_dir": str(work_dir),
+            "file_count": len(saved_files),
+            "total_files": len(session["files"]),
+            "files": saved_files
+        }
+    except Exception as e:
+        # 上传失败，如果是新会话则解锁
+        if is_new_session:
+            global_task_lock["locked"] = False
+            global_task_lock["task_id"] = None
+            global_task_lock["stage"] = None
+            global_task_lock["started_at"] = None
+        raise HTTPException(status_code=500, detail=f"上传失败: {str(e)}")
+
+
+@app.post("/api/upload/complete/{session_id}")
+async def complete_upload_session(session_id: str):
+    """
+    完成上传会话
+    """
+    if session_id not in upload_sessions:
+        raise HTTPException(status_code=404, detail="上传会话不存在")
+    
+    session = upload_sessions[session_id]
+    
+    # 更新历史记录
+    history_manager.update(session_id, file_count=len(session["files"]))
+    
+    # 清理会话（保留一段时间）
+    # upload_sessions.pop(session_id, None)
+    
+    return {
+        "success": True,
+        "session_id": session_id,
+        "total_files": len(session["files"])
+    }
+
+
+# ==================== 处理任务 API ====================
+
+@app.get("/api/routes")
+async def list_routes():
+    """列出所有注册的路由（调试用）"""
+    routes = []
+    for route in app.routes:
+        if hasattr(route, 'path'):
+            routes.append({
+                "path": route.path,
+                "name": route.name if hasattr(route, 'name') else None,
+                "methods": list(route.methods) if hasattr(route, 'methods') else None
+            })
+    return {"routes": routes}
+
+
+@app.post("/api/process/start/test")
+async def test_process_start():
+    """测试 /api/process/start 路由是否可访问"""
+    return {"success": True, "message": "/api/process/start 路由可访问"}
+
+
+@app.get("/api/task/test")
+async def test_task_api():
+    """测试任务API是否正常工作"""
+    return {"success": True, "message": "任务API正常工作", "lock_status": global_task_lock}
+
+
+@app.get("/api/task/status")
+@app.post("/api/task/status")
+async def get_global_task_status():
+    """获取全局任务状态（是否有任务在上传或处理中）"""
+    # 自动清理：如果任务已完成但还锁定，则自动解锁
+    if global_task_lock["locked"]:
+        task_id = global_task_lock["task_id"]
+        if task_id:
+            # 检查任务是否已完成
+            record = history_manager.get(task_id)
+            if record and record.status in ["completed", "failed"]:
+                # 任务已完成但还锁定，自动解锁
+                global_task_lock["locked"] = False
+                global_task_lock["task_id"] = None
+                global_task_lock["stage"] = None
+                global_task_lock["started_at"] = None
+                return {"has_active": False}
+            
+            # 检查内存中的任务状态
+            if task_id in processing_tasks:
+                task_status = processing_tasks[task_id].get("status")
+                if task_status in ["completed", "failed"]:
+                    # 任务已完成但还锁定，自动解锁
+                    global_task_lock["locked"] = False
+                    global_task_lock["task_id"] = None
+                    global_task_lock["stage"] = None
+                    global_task_lock["started_at"] = None
+                    return {"has_active": False}
+        
+        # 任务还在进行中
+        return {
+            "has_active": True,
+            "task_id": global_task_lock["task_id"],
+            "stage": global_task_lock["stage"],
+            "started_at": global_task_lock["started_at"],
+            "logs": []
+        }
+    
+    # 检查内存中正在处理的任务
+    active_tasks = {k: v for k, v in processing_tasks.items() if v.get("status") == "processing"}
+    if active_tasks:
+        task_id = list(active_tasks.keys())[0]
+        return {
+            "has_active": True,
+            "task_id": task_id,
+            "stage": "processing",
+            "logs": active_tasks[task_id].get("logs", [])
+        }
+    
+    # 不检查历史记录，因为历史记录可能是旧的状态
+    # 如果服务器重启，历史记录中的 "processing" 状态可能是过期的
+    
+    return {"has_active": False}
+
+
+@app.post("/api/task/lock")
+async def lock_task(task_id: str = Body(..., embed=True)):
+    """锁定全局任务状态（开始上传时调用）"""
+    if global_task_lock["locked"]:
+        raise HTTPException(status_code=409, detail="已有任务在运行")
+    
+    global_task_lock["locked"] = True
+    global_task_lock["task_id"] = task_id
+    global_task_lock["stage"] = "uploading"
+    global_task_lock["started_at"] = datetime.now().isoformat()
+    
+    return {"success": True, "message": "任务已锁定"}
+
+
+@app.post("/api/task/unlock")
+async def unlock_task(task_id: str = Body(None, embed=True)):
+    """解锁全局任务状态（上传失败或取消时调用）"""
+    # 只有锁定者或管理员可以解锁
+    if task_id and global_task_lock["task_id"] != task_id:
+        raise HTTPException(status_code=403, detail="无权解锁此任务")
+    
+    global_task_lock["locked"] = False
+    global_task_lock["task_id"] = None
+    global_task_lock["stage"] = None
+    global_task_lock["started_at"] = None
+    
+    return {"success": True, "message": "任务已解锁"}
+
+
+@app.get("/api/process/active")
+@app.post("/api/process/active")
+async def get_active_task():
+    """获取当前正在进行的任务（全局状态）- 兼容旧接口"""
+    return await get_global_task_status()
+
+
+@app.post("/api/process/start")
+async def start_processing(task_id: str = Body(..., embed=True)):
+    """启动数据处理任务（task_id 放在 POST body 中）"""
+    record = history_manager.get(task_id)
+    if not record:
+        raise HTTPException(status_code=404, detail="任务不存在")
+    
+    if record.status == "processing":
+        raise HTTPException(status_code=400, detail="任务正在处理中")
+    
+    work_dir = Path(record.work_dir)
+    if not work_dir.exists():
+        raise HTTPException(status_code=400, detail="工作目录不存在")
+    
+    # 创建日志记录器（实时写入 log.txt）
+    log_file = work_dir / "log.txt"
+    logs: List[str] = []
+    def log_callback(msg: str):
+        logs.append(msg)
+        processing_tasks[task_id] = {"logs": logs, "status": "processing"}
+    
+    logger = ProcessLogger(log_file=log_file, callback=log_callback)
+    
+    # 更新状态
+    history_manager.update(task_id, status="processing")
+    processing_tasks[task_id] = {"logs": logs, "status": "processing"}
+    
+    # 更新全局锁定状态为处理中
+    global_task_lock["locked"] = True
+    global_task_lock["task_id"] = task_id
+    global_task_lock["stage"] = "processing"
+    global_task_lock["started_at"] = datetime.now().isoformat()
+    
+    # 在后台线程执行处理
+    def run_processing():
+        try:
+            processor = DataProcessor(config, work_dir, logger)
+            result = processor.process()
+            
+            # 更新历史记录（日志已写入文件，不需要再保存）
+            status = "completed" if result.get("success") else "failed"
+            history_manager.update(
+                task_id,
+                status=status,
+                elapsed_time=result.get("elapsed_time", 0),
+                error=result.get("error"),
+                result_tables=["4G_结果表", "5G_结果表"]
+            )
+            # 从文件读取最新日志
+            logs_from_file = history_manager.get_logs(task_id)
+            processing_tasks[task_id] = {"logs": logs_from_file, "status": status}
+            # 处理完成，解锁全局状态
+            global_task_lock["locked"] = False
+            global_task_lock["task_id"] = None
+            global_task_lock["stage"] = None
+            global_task_lock["started_at"] = None
+        except Exception as e:
+            history_manager.update(task_id, status="failed", error=str(e))
+            # 从文件读取最新日志
+            logs_from_file = history_manager.get_logs(task_id)
+            processing_tasks[task_id] = {"logs": logs_from_file, "status": "failed"}
+            # 处理失败，解锁全局状态
+            global_task_lock["locked"] = False
+            global_task_lock["task_id"] = None
+            global_task_lock["stage"] = None
+            global_task_lock["started_at"] = None
+    
+    thread = Thread(target=run_processing)
+    thread.start()
+    
+    return {"success": True, "message": "处理任务已启动", "task_id": task_id}
+
+
+@app.post("/api/process/status")
+async def get_processing_status(task_id: str = Body(..., embed=True)):
+    """获取处理任务状态和日志（task_id 放在 POST body 中）"""
+    # 优先从文件读取日志（实时写入，保证最新）
+    logs = history_manager.get_logs(task_id)
+    
+    # 检查内存中的实时状态（用于获取状态）
+    if task_id in processing_tasks:
+        return {
+            "task_id": task_id,
+            "status": processing_tasks[task_id]["status"],
+            "logs": logs  # 使用文件中的日志
+        }
+    
+    # 从历史记录获取
+    record = history_manager.get(task_id)
+    if not record:
+        raise HTTPException(status_code=404, detail="任务不存在")
+    
+    return {
+        "task_id": task_id,
+        "status": record.status,
+        "logs": logs,
+        "elapsed_time": record.elapsed_time,
+        "error": record.error
+    }
+
+
+# ==================== 历史记录 API ====================
+
+@app.post("/api/history")
+async def get_history(limit: int = Body(50, embed=True)):
+    """获取处理历史记录"""
+    records = history_manager.list(limit)
+    return {"records": records}
+
+
+@app.post("/api/history/delete")
+async def delete_history(record_id: str = Body(..., embed=True)):
+    """删除历史记录"""
+    if history_manager.delete(record_id):
+        return {"success": True, "message": "删除成功"}
+    raise HTTPException(status_code=404, detail="记录不存在")
+
+
+@app.post("/api/history/clear")
+async def clear_history():
+    """清空所有历史记录"""
+    count = history_manager.clear()
+    return {"success": True, "deleted": count}
+
+
+@app.post("/api/history/detail")
+async def get_history_detail(record_id: str = Body(..., embed=True)):
+    """获取历史记录详情（record_id 放在 POST body 中）"""
+    record = history_manager.get(record_id)
+    if not record:
+        raise HTTPException(status_code=404, detail="记录不存在")
+    
+    # 从文件读取日志
+    logs = history_manager.get_logs(record_id)
+    result = record.to_dict()
+    result["logs"] = logs
+    
+    return result
+
+
+# ==================== 数据库管理 API ====================
+
+@app.get("/api/database/test")
+@app.post("/api/database/test")
+async def test_database():
+    """测试数据库连接（支持 GET 和 POST，无需传参）"""
+    db = DatabaseManager(config)
+    success, message = db.test_connection()
+    db.dispose()
+    return {"success": success, "message": message}
+
+
+@app.get("/api/database/tables")
+@app.post("/api/database/tables")
+async def get_tables():
+    """获取所有表（支持 GET 和 POST，无需传参）"""
+    try:
+        db = DatabaseManager(config)
+        tables = db.get_tables()
+        db.dispose()
+        return {"tables": tables}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/database/table/info")
+async def get_table_info(table_name: str = Body(..., embed=True)):
+    """获取表信息（table_name 放在 POST body 中）"""
+    try:
+        db = DatabaseManager(config)
+        info = db.get_table_info(table_name)
+        db.dispose()
+        return info
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/database/table/data")
+async def query_table_data(
+    table_name: str = Body(..., embed=True),
+    page: int = Body(1),
+    page_size: int = Body(50),
+    order_by: Optional[str] = Body(None),
+    order_dir: str = Body("ASC")
+):
+    """分页查询表数据（参数放在 POST body 中）"""
+    try:
+        db = DatabaseManager(config)
+        result = db.query_table(table_name, page, page_size, order_by=order_by, order_dir=order_dir)
+        db.dispose()
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/database/table/query")
+async def query_table_with_filter(
+    table_name: str = Body(..., embed=True),
+    page: int = Body(1),
+    page_size: int = Body(50),
+    filters: Dict[str, str] = Body(default={}),
+    order_by: Optional[str] = Body(None),
+    order_dir: str = Body("ASC")
+):
+    """带筛选条件查询表数据（参数放在 POST body 中）"""
+    try:
+        db = DatabaseManager(config)
+        result = db.query_table(table_name, page, page_size, filters=filters, order_by=order_by, order_dir=order_dir)
+        db.dispose()
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/database/table/truncate")
+async def truncate_table(table_name: str = Body(..., embed=True)):
+    """清空表数据（table_name 放在 POST body 中）"""
+    try:
+        db = DatabaseManager(config)
+        db.truncate_table(table_name)
+        db.dispose()
+        return {"success": True, "message": f"表 {table_name} 已清空"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/database/table/drop")
+async def drop_table(table_name: str = Body(..., embed=True)):
+    """删除表（table_name 放在 POST body 中）"""
+    try:
+        db = DatabaseManager(config)
+        db.drop_table(table_name)
+        db.dispose()
+        return {"success": True, "message": f"表 {table_name} 已删除"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/database/execute")
+async def execute_sql(sql: str = Body(..., embed=True)):
+    """执行自定义 SQL"""
+    try:
+        db = DatabaseManager(config)
+        success, result = db.execute_sql(sql)
+        db.dispose()
+        
+        if success:
+            return {"success": True, "result": result}
+        else:
+            raise HTTPException(status_code=400, detail=result)
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# ==================== 下载功能 API ====================
+
+@app.post("/api/download")
+async def download_table(
+    table_name: str = Body(..., embed=True),
+    format: str = Body("csv")
+):
+    """下载表数据（table_name/format 放在 POST body 中）"""
+    try:
+        db = DatabaseManager(config)
+        result = db.query_table(table_name, page=1, page_size=1000000)  # 获取所有数据
+        db.dispose()
+        
+        import pandas as pd
+        df = pd.DataFrame(result["data"])
+        
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"{table_name}_{timestamp}.{format}"
+        filepath = CACHE_DIR / filename
+        
+        if format == "csv":
+            df.to_csv(filepath, index=False, encoding='utf-8-sig')
+            media_type = "text/csv"
+        else:
+            df.to_excel(filepath, index=False)
+            media_type = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+        
+        return FileResponse(
+            path=str(filepath),
+            filename=filename,
+            media_type=media_type
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# ==================== 配置 API ====================
+
+@app.get("/api/config")
+async def get_config():
+    """获取当前配置（隐藏密码）"""
+    return config.to_dict()
+
+
+@app.get("/api/config/full")
+async def get_config_full():
+    """获取完整配置（包含密码，用于编辑回显）"""
+    return config.to_dict_full()
+
+
+@app.post("/api/config/mysql")
+async def update_mysql_config(
+    host: str = Body(...),
+    port: int = Body(...),
+    user: str = Body(...),
+    passwd: str = Body(...),
+    dbname: str = Body(...)
+):
+    """更新数据库配置"""
+    global config
+    
+    config.mysql.host = host
+    config.mysql.port = port
+    config.mysql.user = user
+    config.mysql.passwd = passwd
+    config.mysql.dbname = dbname
+    config.save()
+    
+    return {"success": True, "message": "数据库配置已更新", "update": config.update}
+
+
+@app.post("/api/config/sheet-filter")
+async def update_sheet_filter(filters: List[str] = Body(...)):
+    """更新 Sheet 过滤规则"""
+    global config
+    
+    config.sheet_filter = filters
+    config.save()
+    
+    return {"success": True, "message": "Sheet 过滤规则已更新", "update": config.update}
+
+
+@app.post("/api/config/extract-fields")
+async def update_extract_fields(fields: List[Dict[str, Any]] = Body(...)):
+    """更新字段映射配置"""
+    global config
+    
+    config.extract_fields = fields
+    config.save()
+    
+    return {"success": True, "message": "字段映射配置已更新", "update": config.update}
+
+
+# ==================== 清理 API ====================
+
+@app.get("/api/cache/size")
+@app.post("/api/cache/size")
+async def get_cache_size():
+    """获取 cache 目录占用大小（无需传参）"""
+    try:
+        total_size = 0
+        file_count = 0
+        dir_count = 0
+        
+        def get_dir_size(path: Path):
+            """递归计算目录大小"""
+            nonlocal total_size, file_count, dir_count
+            try:
+                if path.is_file():
+                    total_size += path.stat().st_size
+                    file_count += 1
+                elif path.is_dir():
+                    dir_count += 1
+                    for item in path.iterdir():
+                        get_dir_size(item)
+            except (PermissionError, OSError):
+                pass
+        
+        # 计算 cache 目录大小（排除 history.json）
+        for item in CACHE_DIR.iterdir():
+            if item.name != "history.json":
+                get_dir_size(item)
+        
+        # 格式化大小
+        def format_size(size_bytes):
+            for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
+                if size_bytes < 1024.0:
+                    return f"{size_bytes:.2f} {unit}"
+                size_bytes /= 1024.0
+            return f"{size_bytes:.2f} PB"
+        
+        return {
+            "success": True,
+            "size_bytes": total_size,
+            "size_formatted": format_size(total_size),
+            "file_count": file_count,
+            "dir_count": dir_count
+        }
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e),
+            "size_formatted": "计算失败"
+        }
+
+
+def get_dir_size(path: Path) -> int:
+    """递归计算目录大小"""
+    total_size = 0
+    try:
+        if path.is_file():
+            total_size += path.stat().st_size
+        elif path.is_dir():
+            for item in path.iterdir():
+                total_size += get_dir_size(item)
+    except (PermissionError, OSError):
+        pass
+    return total_size
+
+
+def format_size(size_bytes: int) -> str:
+    """格式化文件大小"""
+    for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
+        if size_bytes < 1024.0:
+            return f"{size_bytes:.2f} {unit}"
+        size_bytes /= 1024.0
+    return f"{size_bytes:.2f} PB"
+
+
+@app.post("/api/history/size")
+async def get_history_size(record_id: str = Body(..., embed=True)):
+    """获取单个历史记录的占用大小"""
+    record = history_manager.get(record_id)
+    if not record:
+        raise HTTPException(status_code=404, detail="记录不存在")
+    
+    work_dir = Path(record.work_dir)
+    if not work_dir.exists():
+        return {"success": True, "size": 0, "size_formatted": "0 B"}
+    
+    try:
+        size = get_dir_size(work_dir)
+        return {
+            "success": True,
+            "size": size,
+            "size_formatted": format_size(size)
+        }
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e),
+            "size_formatted": "计算失败"
+        }
+
+
+# ==================== 服务管理 API ====================
+
+def is_supervisor_running() -> bool:
+    """检查是否在 supervisor 环境下运行"""
+    # 检查 supervisor socket 文件是否存在
+    supervisor_sock = Path("/var/run/supervisor.sock")
+    if supervisor_sock.exists():
+        return True
+    
+    # 检查环境变量
+    if os.environ.get("SUPERVISOR_ENABLED") == "1":
+        return True
+    
+    # 检查父进程是否是 supervisord
+    try:
+        import psutil  # pyright: ignore[reportMissingModuleSource]
+        current = psutil.Process()
+        parent = current.parent()
+        if parent and "supervisor" in parent.name().lower():
+            return True
+    except:
+        pass
+    
+    return False
+
+
+def restart_via_supervisor() -> tuple:
+    """通过 supervisor 重启服务"""
+    try:
+        result = subprocess.run(
+            ["supervisorctl", "restart", "fastapi"],
+            capture_output=True,
+            text=True,
+            timeout=30
+        )
+        if result.returncode == 0:
+            return True, "服务正在通过 supervisor 重启..."
+        else:
+            return False, f"重启失败: {result.stderr or result.stdout}"
+    except subprocess.TimeoutExpired:
+        return False, "重启操作超时"
+    except FileNotFoundError:
+        return False, "找不到 supervisorctl 命令"
+    except Exception as e:
+        return False, f"重启异常: {str(e)}"
+
+
+def restart_via_signal() -> tuple:
+    """通过信号重启服务（适用于非 supervisor 环境）"""
+    try:
+        # 获取当前进程 PID
+        pid = os.getpid()
+        
+        if platform.system() == "Windows":
+            # Windows: 通过结束进程的方式触发重启
+            # 需要配合外部重启机制（如 Docker restart policy 或 bat 脚本）
+            os._exit(0)
+        else:
+            # Linux/Mac: 发送 SIGHUP 信号让进程重启
+            # 或者直接退出，依赖外部重启机制
+            os.kill(pid, signal.SIGTERM)
+        
+        return True, "服务正在重启..."
+    except Exception as e:
+        return False, f"重启失败: {str(e)}"
+
+
+@app.post("/api/service/restart")
+async def restart_service():
+    """
+    重启服务
+    - 在 supervisor 环境下使用 supervisorctl restart
+    - 在非 supervisor 环境下发送信号或退出进程
+    """
+    # 检查是否在 supervisor 环境下
+    if is_supervisor_running():
+        success, message = restart_via_supervisor()
+    else:
+        # 非 supervisor 环境，使用延迟退出
+        # 先返回响应，然后在后台线程中退出进程
+        def delayed_exit():
+            import time
+            time.sleep(1)  # 等待响应发送完成
+            if platform.system() == "Windows":
+                os._exit(0)
+            else:
+                os.kill(os.getpid(), signal.SIGTERM)
+        
+        thread = Thread(target=delayed_exit, daemon=True)
+        thread.start()
+        
+        return {
+            "success": True,
+            "message": "服务正在重启，请稍后刷新页面...",
+            "method": "signal"
+        }
+    
+    return {
+        "success": success,
+        "message": message,
+        "method": "supervisor" if is_supervisor_running() else "signal"
+    }
+
+
+@app.get("/api/service/status")
+async def get_service_status():
+    """获取服务运行状态"""
+    return {
+        "status": "running",
+        "version": "2.0.0",
+        "platform": platform.system(),
+        "supervisor": is_supervisor_running(),
+        "pid": os.getpid(),
+        "python_version": platform.python_version()
+    }
+
+
+# ==================== 启动入口 ====================
+
+if __name__ == "__main__":
+    import uvicorn
+    print(f"CapacityReport v2.0.0")
+    print(f"配置更新时间: {config.update}")
+    uvicorn.run("app.main:app", host="0.0.0.0", port=9081, reload=False)
diff --git a/app/processor.py b/app/processor.py
new file mode 100644
index 0000000..0f164af
--- /dev/null
+++ b/app/processor.py
@@ -0,0 +1,426 @@
+"""
+数据处理核心模块 - 性能优化版
+"""
+import os
+import re
+import time
+import zipfile
+import multiprocessing
+import numpy as np
+import pandas as pd
+import sqlparse
+from pathlib import Path
+from typing import Any, Callable, Dict, Generator, List, Optional, Tuple
+from datetime import datetime
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from io import StringIO
+
+from app.config import AppConfig, SQL_SCRIPT
+from app.database import DatabaseManager
+
+
+class ProcessLogger:
+    """处理日志记录器"""
+    
+    def __init__(self, log_file: Optional[Path] = None, callback: Optional[Callable[[str], None]] = None):
+        self.logs: List[str] = []
+        self.log_file = log_file
+        self.callback = callback
+        # 如果指定了日志文件，确保目录存在
+        if self.log_file:
+            self.log_file.parent.mkdir(parents=True, exist_ok=True)
+            # 清空或创建日志文件
+            self.log_file.write_text("", encoding='utf-8')
+    
+    def log(self, message: str, level: str = "INFO"):
+        """记录日志"""
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        entry = f"[{timestamp}] [{level}] {message}"
+        self.logs.append(entry)
+        
+        # 实时写入文件
+        if self.log_file:
+            try:
+                with self.log_file.open("a", encoding='utf-8') as f:
+                    f.write(entry + "\n")
+            except Exception as e:
+                # 如果写入失败，至少记录到内存
+                print(f"写入日志文件失败: {e}")
+        
+        if self.callback:
+            self.callback(entry)
+    
+    def info(self, message: str):
+        self.log(message, "INFO")
+    
+    def error(self, message: str):
+        self.log(message, "ERROR")
+    
+    def warning(self, message: str):
+        self.log(message, "WARN")
+    
+    def success(self, message: str):
+        self.log(message, "SUCCESS")
+    
+    def get_logs(self) -> List[str]:
+        return self.logs.copy()
+
+
+class DataProcessor:
+    """数据处理器 - 高性能版"""
+    
+    # 批量插入大小（根据实际测试，5000 是比较好的平衡点）
+    BATCH_SIZE = 5000
+    # Excel 并行处理的最大线程数（根据 CPU 核心数自动调整）
+    # 使用 CPU 核心数，但至少为 1，最多不超过 8（避免过多线程导致上下文切换开销）
+    MAX_WORKERS = min(max(multiprocessing.cpu_count(), 1), 8)
+    
+    def __init__(self, config: AppConfig, work_dir: Path, logger: ProcessLogger):
+        self.config = config
+        self.work_dir = work_dir
+        self.logger = logger
+        self.db = DatabaseManager(config)
+        self.results: Dict[str, Any] = {}
+        
+        # 预编译字段映射，避免重复查找
+        self._field_map = self._build_field_map()
+    
+    def _build_field_map(self) -> Dict[str, str]:
+        """预构建字段映射表，提高查找效率"""
+        field_map = {}
+        for field_def in self.config.extract_fields:
+            db_field = field_def.get("Field")
+            for extract_name in field_def.get("Extract", []):
+                field_map[extract_name] = db_field
+        return field_map
+    
+    def process(self) -> Dict[str, Any]:
+        """执行完整的数据处理流程"""
+        start_time = time.time()
+        self.logger.info(f"开始处理数据，工作目录: {self.work_dir}")
+        
+        try:
+            # 1. 解压 ZIP 文件
+            self._unzip_files()
+            
+            # 2. 处理 Excel 文件（并行）
+            self._process_excel_files_parallel()
+            
+            # 3. 处理 CSV 文件并上传到数据库（高性能批量插入）
+            self._process_csv_files()
+            
+            # 4. 执行 SQL 脚本
+            self._execute_sql_script()
+            
+            elapsed = round(time.time() - start_time, 2)
+            self.logger.success(f"处理完成！总耗时: {elapsed} 秒")
+            
+            self.results["success"] = True
+            self.results["elapsed_time"] = elapsed
+            
+        except Exception as e:
+            self.logger.error(f"处理失败: {str(e)}")
+            self.results["success"] = False
+            self.results["error"] = str(e)
+        
+        finally:
+            self.db.dispose()
+        
+        return self.results
+    
+    def _unzip_files(self):
+        """解压所有 ZIP 文件（支持中文文件名）"""
+        self.logger.info("正在解压 ZIP 文件...")
+        zip_files = list(self.work_dir.rglob("*.zip"))
+        zip_count = 0
+        
+        for zip_file in zip_files:
+            try:
+                rel_path = zip_file.relative_to(self.work_dir)
+                self.logger.info(f"解压: {rel_path}")
+                self._extract_zip_with_encoding(zip_file)
+                zip_count += 1
+            except Exception as e:
+                rel_path = zip_file.relative_to(self.work_dir)
+                self.logger.error(f"解压失败 {rel_path}: {e}")
+        
+        self.logger.info(f"ZIP 解压完成，共 {zip_count} 个文件")
+    
+    def _extract_zip_with_encoding(self, zip_file: Path):
+        """
+        解压 ZIP 文件，自动处理中文文件名编码问题
+        支持 UTF-8、GBK、CP437 等多种编码
+        """
+        # 优先尝试 UTF-8（现代 ZIP 文件标准）
+        try:
+            with zipfile.ZipFile(zip_file, 'r', metadata_encoding='utf-8') as zf:
+                zf.extractall(zip_file.parent)
+                return
+        except (UnicodeDecodeError, zipfile.BadZipFile):
+            # UTF-8 失败，尝试 GBK（Windows 中文系统常用）
+            try:
+                with zipfile.ZipFile(zip_file, 'r', metadata_encoding='gbk') as zf:
+                    zf.extractall(zip_file.parent)
+                    return
+            except (UnicodeDecodeError, zipfile.BadZipFile):
+                # GBK 也失败，尝试 CP437（DOS 编码）
+                try:
+                    with zipfile.ZipFile(zip_file, 'r', metadata_encoding='cp437') as zf:
+                        zf.extractall(zip_file.parent)
+                        return
+                except Exception as e:
+                    # 所有编码都失败
+                    raise Exception(f"无法解压 ZIP 文件，编码检测失败: {e}")
+    
+    def _scan_files(self, directory: Path, extensions: List[str]) -> Generator[Path, None, None]:
+        """扫描指定扩展名的文件"""
+        for ext in extensions:
+            for file in directory.rglob(f"*{ext}"):
+                yield file
+    
+    def _process_single_excel(self, excel_file: Path, sheet_filter: set) -> int:
+        """处理单个 Excel 文件（用于并行）"""
+        processed = 0
+        try:
+            rel_path = excel_file.relative_to(self.work_dir)
+            
+            # 使用 openpyxl 的 read_only 模式会更快，但这里保持兼容性
+            xl = pd.ExcelFile(excel_file, engine='openpyxl')
+            
+            for sheet_name in xl.sheet_names:
+                if sheet_name not in sheet_filter:
+                    output_file = excel_file.parent / f"{excel_file.stem}_{sheet_name}.csv"
+                    # 直接读取并写入，不做额外处理
+                    df = xl.parse(sheet_name)
+                    df.to_csv(output_file, index=False, encoding='utf-8')
+                    processed += 1
+            
+            xl.close()
+            return processed
+            
+        except Exception as e:
+            rel_path = excel_file.relative_to(self.work_dir)
+            self.logger.error(f"Excel 处理失败 {rel_path}: {e}")
+            return 0
+    
+    def _process_excel_files_parallel(self):
+        """并行处理 Excel 文件"""
+        self.logger.info("正在并行处理 Excel 文件...")
+        excel_files = list(self._scan_files(self.work_dir, ['.xlsx', '.xls']))
+        self.logger.info(f"找到 {len(excel_files)} 个 Excel 文件")
+        
+        if not excel_files:
+            return
+        
+        sheet_filter = set(self.config.sheet_filter)
+        total_processed = 0
+        
+        # 使用线程池并行处理
+        with ThreadPoolExecutor(max_workers=self.MAX_WORKERS) as executor:
+            futures = {
+                executor.submit(self._process_single_excel, f, sheet_filter): f 
+                for f in excel_files
+            }
+            
+            for future in as_completed(futures):
+                excel_file = futures[future]
+                try:
+                    count = future.result()
+                    total_processed += count
+                    rel_path = excel_file.relative_to(self.work_dir)
+                    if count > 0:
+                        self.logger.info(f"处理完成: {rel_path} ({count} 个 sheet)")
+                except Exception as e:
+                    rel_path = excel_file.relative_to(self.work_dir)
+                    self.logger.error(f"Excel 处理异常 {rel_path}: {e}")
+        
+        self.logger.info(f"Excel 处理完成，共生成 {total_processed} 个 CSV 文件")
+    
+    def _detect_encoding(self, file_path: Path) -> str:
+        """快速检测文件编码（只读取前 8KB）"""
+        import chardet
+        with open(file_path, 'rb') as f:
+            # 只读取前 8KB，足够检测编码，比 64KB 快很多
+            result = chardet.detect(f.read(8192))
+        encoding = result.get('encoding', 'utf-8') or 'utf-8'
+        encoding = encoding.lower()
+        if 'utf' in encoding:
+            return 'utf-8'
+        elif 'gb' in encoding:
+            return 'gbk'
+        return 'utf-8'
+    
+    def _process_csv_file_fast(self, csv_file: Path, table_name: str) -> int:
+        """
+        高性能处理单个 CSV 文件
+        使用批量插入代替 to_sql，性能提升 5-10 倍
+        """
+        encoding = self._detect_encoding(csv_file)
+        rel_path = csv_file.relative_to(self.work_dir)
+        self.logger.info(f"处理 CSV: {rel_path} (编码: {encoding})")
+        
+        # 读取 CSV，使用优化参数
+        df = pd.read_csv(
+            csv_file, 
+            encoding=encoding, 
+            thousands=',', 
+            low_memory=True,        # 低内存模式
+            dtype=str,              # 全部作为字符串读取，避免类型推断开销
+            na_values=[''],         # 只把空字符串当作 NA
+            keep_default_na=False   # 不使用默认的 NA 值
+        )
+        
+        # 快速字段匹配（使用预编译的映射表）
+        col_mapping = {}
+        for col in df.columns:
+            if col in self._field_map:
+                col_mapping[col] = self._field_map[col]
+        
+        if len(col_mapping) <= 3:
+            if 'kpis' in str(csv_file).lower():
+                self.logger.warning(f"跳过非数据文件: {rel_path}")
+                return 0
+            raise ValueError(f"字段匹配不足: {rel_path}")
+        
+        # 选择需要的列并重命名
+        source_cols = list(col_mapping.keys())
+        target_cols = list(col_mapping.values())
+        
+        df_result = df[source_cols]
+        
+        # 向量化数据清洗（比逐列循环快 10 倍以上）
+        # 替换 NA 为 '0'，去除百分号，截断长度
+        df_result = df_result.fillna('0')
+        
+        # 使用 numpy 向量化操作
+        for col in df_result.columns:
+            # 去除百分号
+            df_result[col] = df_result[col].str.replace('%', '', regex=False)
+            # 截断超长字符串
+            mask = df_result[col].str.len() > 200
+            if mask.any():
+                df_result.loc[mask, col] = df_result.loc[mask, col].str[:200]
+        
+        # 确保表存在
+        self.db.create_table_from_columns(table_name, target_cols)
+        
+        # 转换为元组列表，用于批量插入
+        # 这比 to_sql 快很多
+        data_tuples = [tuple(row) for row in df_result.values]
+        
+        # 使用批量插入
+        inserted = self.db.bulk_insert(table_name, target_cols, data_tuples, self.BATCH_SIZE)
+        
+        return inserted
+    
+    def _find_data_directories(self) -> Dict[str, Path]:
+        """
+        查找包含数据文件的目录，返回 {表名: 目录路径}
+        """
+        data_dirs = {}
+        target_names = {'4G', '5G', '4g', '5g'}
+        
+        self.logger.info(f"开始查找数据目录，工作目录: {self.work_dir}")
+        
+        # 递归查找所有名为 4G 或 5G 的目录
+        found_dirs = []
+        for subdir in self.work_dir.rglob('*'):
+            if subdir.is_dir() and subdir.name in target_names:
+                found_dirs.append(subdir)
+        
+        self.logger.info(f"找到 {len(found_dirs)} 个候选目录")
+        
+        for subdir in found_dirs:
+            table_name = f"{subdir.name.upper()}_UD"
+            if table_name not in data_dirs:
+                data_dirs[table_name] = subdir
+                self.logger.info(f"发现数据目录: {subdir.relative_to(self.work_dir)} -> 表: {table_name}")
+        
+        if not data_dirs:
+            self.logger.warning("未找到 4G/5G 目录，使用直接子目录")
+            for subdir in self.work_dir.iterdir():
+                if subdir.is_dir():
+                    table_name = f"{subdir.name}_UD"
+                    data_dirs[table_name] = subdir
+                    self.logger.info(f"使用直接子目录: {subdir.relative_to(self.work_dir)} -> 表: {table_name}")
+        
+        return data_dirs
+    
+    def _process_csv_files(self):
+        """处理所有 CSV 文件（高性能版）"""
+        self.logger.info("正在处理 CSV 文件并上传到数据库...")
+        
+        # 查找数据目录
+        data_dirs = self._find_data_directories()
+        
+        if not data_dirs:
+            self.logger.warning("未找到任何数据目录")
+            return
+        
+        # 按目录分组处理
+        for table_name, subdir in data_dirs.items():
+            self.logger.info(f"处理目录: {subdir.relative_to(self.work_dir)} -> 表: {table_name}")
+            
+            # 删除旧表
+            self.db.drop_table(table_name)
+            
+            # 处理该目录下的所有 CSV
+            csv_files = list(self._scan_files(subdir, ['.csv']))
+            self.logger.info(f"找到 {len(csv_files)} 个 CSV 文件")
+            
+            total_rows = 0
+            start_time = time.time()
+            
+            for i, csv_file in enumerate(csv_files, 1):
+                try:
+                    rows = self._process_csv_file_fast(csv_file, table_name)
+                    total_rows += rows
+                    
+                    # 每处理 10 个文件报告一次进度
+                    if i % 10 == 0:
+                        elapsed = round(time.time() - start_time, 1)
+                        self.logger.info(f"进度: {i}/{len(csv_files)} 文件, 已导入 {total_rows} 行, 耗时 {elapsed}s")
+                        
+                except Exception as e:
+                    rel_path = csv_file.relative_to(self.work_dir)
+                    self.logger.error(f"CSV 处理失败 {rel_path}: {e}")
+            
+            elapsed = round(time.time() - start_time, 2)
+            speed = round(total_rows / elapsed) if elapsed > 0 else 0
+            self.logger.success(f"表 {table_name} 导入完成: {total_rows} 行, 耗时 {elapsed}s, 速度 {speed} 行/秒")
+    
+    def _execute_sql_script(self):
+        """执行 SQL 脚本"""
+        if not SQL_SCRIPT.exists():
+            self.logger.warning("SQL 脚本文件不存在，跳过")
+            return
+        
+        self.logger.info("正在执行 SQL 脚本...")
+        
+        with open(SQL_SCRIPT, 'r', encoding='utf-8') as f:
+            sql_text = f.read()
+        
+        sqls = sqlparse.split(sql_text)
+        total = len(sqls)
+        
+        with self.db.get_connection() as conn:
+            with conn.cursor() as cursor:
+                for i, sql in enumerate(sqls, 1):
+                    sql = sql.strip()
+                    if not sql or sql.startswith('#'):
+                        continue
+                    
+                    start_time = time.time()
+                    preview = sql[:80].replace('\n', ' ')
+                    self.logger.info(f"执行 SQL ({i}/{total}): {preview}...")
+                    
+                    try:
+                        cursor.execute(sql)
+                        elapsed = round(time.time() - start_time, 2)
+                        self.logger.info(f"完成，耗时 {elapsed} 秒")
+                    except Exception as e:
+                        self.logger.error(f"SQL 执行失败: {e}")
+                
+                conn.commit()
+        
+        self.logger.success("SQL 脚本执行完成")
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..cc543f1
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,22 @@
+# Web Framework
+fastapi
+uvicorn[standard]
+python-multipart
+
+# Database
+pymysql
+sqlalchemy
+cryptography
+
+# Data Processing
+pandas
+openpyxl
+chardet
+sqlparse
+
+# Utilities
+aiofiles
+python-dateutil
+
+# Process Manager
+supervisor
diff --git a/run.bat b/run.bat
new file mode 100644
index 0000000..891ac62
--- /dev/null
+++ b/run.bat
@@ -0,0 +1,40 @@
+@echo off
+chcp 65001 >nul
+title CapacityReport v2.0.0 [自动重启模式]
+
+echo ========================================
+echo   CapacityReport - 容量报表处理程序
+echo   自动重启模式
+echo ========================================
+echo.
+
+cd /d "%~dp0"
+
+:: 检查 Python 环境
+python --version >nul 2>&1
+if errorlevel 1 (
+    echo [错误] 未找到 Python，请先安装 Python 3.8+
+    pause
+    exit /b 1
+)
+
+:: 检查依赖
+pip show fastapi >nul 2>&1
+if errorlevel 1 (
+    echo [提示] 正在安装依赖...
+    pip install -r requirements.txt
+)
+
+:loop
+echo.
+echo [%date% %time%] 启动服务...
+echo [启动] 服务地址: http://localhost:9081
+echo [提示] 关闭此窗口可完全停止服务
+echo.
+
+python -m app.main
+
+echo.
+echo [%date% %time%] 服务已停止，3秒后自动重启...
+timeout /t 3 /nobreak >nul
+goto loop
diff --git a/static/css/style.css b/static/css/style.css
new file mode 100644
index 0000000..58d71b1
--- /dev/null
+++ b/static/css/style.css
@@ -0,0 +1,1992 @@
+/* ==================== TDesign 风格变量 ==================== */
+:root {
+    /* 品牌色 */
+    --td-brand-color: #0052d9;
+    --td-brand-color-hover: #0034b5;
+    --td-brand-color-active: #002a9c;
+    --td-brand-color-light: #ecf2fe;
+    --td-brand-color-focus: rgba(0, 82, 217, 0.2);
+    
+    /* 功能色 */
+    --td-success-color: #00a870;
+    --td-success-color-light: #e8f8f2;
+    --td-warning-color: #ed7b2f;
+    --td-warning-color-light: #fef3e6;
+    --td-error-color: #e34d59;
+    --td-error-color-light: #fdecee;
+    --td-info-color: #0052d9;
+    
+    /* 中性色 - 亮色主题 */
+    --td-text-color-primary: rgba(0, 0, 0, 0.9);
+    --td-text-color-secondary: rgba(0, 0, 0, 0.6);
+    --td-text-color-placeholder: rgba(0, 0, 0, 0.4);
+    --td-text-color-disabled: rgba(0, 0, 0, 0.26);
+    --td-text-color-anti: #ffffff;
+    
+    /* 背景色 - 亮色主题 */
+    --td-bg-color-page: #f3f3f3;
+    --td-bg-color-container: #ffffff;
+    --td-bg-color-container-hover: #f3f3f3;
+    --td-bg-color-container-active: #e7e7e7;
+    --td-bg-color-container-select: #e7e7e7;
+    --td-bg-color-secondarycontainer: #f3f3f3;
+    --td-bg-color-component: #f3f3f3;
+    --td-bg-color-component-hover: #e7e7e7;
+    --td-bg-color-component-disabled: #eeeeee;
+    
+    /* 边框色 */
+    --td-border-color: #dcdcdc;
+    --td-border-color-light: #e7e7e7;
+    
+    /* 遮罩 */
+    --td-mask-color: rgba(0, 0, 0, 0.6);
+    
+    /* 阴影 */
+    --td-shadow-1: 0 1px 10px rgba(0, 0, 0, 0.05), 0 4px 5px rgba(0, 0, 0, 0.08), 0 2px 4px -1px rgba(0, 0, 0, 0.12);
+    --td-shadow-2: 0 3px 14px 2px rgba(0, 0, 0, 0.05), 0 8px 10px 1px rgba(0, 0, 0, 0.06), 0 5px 5px -3px rgba(0, 0, 0, 0.1);
+    --td-shadow-3: 0 6px 30px 5px rgba(0, 0, 0, 0.05), 0 16px 24px 2px rgba(0, 0, 0, 0.04), 0 8px 10px -5px rgba(0, 0, 0, 0.08);
+    
+    /* 圆角 */
+    --td-radius-small: 3px;
+    --td-radius-default: 6px;
+    --td-radius-medium: 9px;
+    --td-radius-large: 12px;
+    --td-radius-extraLarge: 16px;
+    
+    /* 字体 */
+    --td-font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", "PingFang SC", "Noto Sans SC", "Microsoft YaHei", sans-serif;
+    --td-font-family-mono: "SFMono-Regular", Consolas, "Liberation Mono", Menlo, Courier, monospace;
+    
+    /* 尺寸 */
+    --sidebar-width: 220px;
+    --sidebar-width-collapsed: 64px;
+    
+    /* 过渡 */
+    --td-transition: 0.2s cubic-bezier(0.38, 0, 0.24, 1);
+}
+
+/* 暗色主题 */
+[data-theme="dark"] {
+    --td-brand-color: #4787f0;
+    --td-brand-color-hover: #618dff;
+    --td-brand-color-active: #366ef4;
+    --td-brand-color-light: #1b2f51;
+    --td-brand-color-focus: rgba(71, 135, 240, 0.35);
+    
+    --td-success-color: #00a870;
+    --td-success-color-light: #0d3926;
+    --td-warning-color: #ed7b2f;
+    --td-warning-color-light: #4f2a1d;
+    --td-error-color: #e34d59;
+    --td-error-color-light: #4b191d;
+    
+    --td-text-color-primary: rgba(255, 255, 255, 0.9);
+    --td-text-color-secondary: rgba(255, 255, 255, 0.55);
+    --td-text-color-placeholder: rgba(255, 255, 255, 0.35);
+    --td-text-color-disabled: rgba(255, 255, 255, 0.22);
+    
+    --td-bg-color-page: #181818;
+    --td-bg-color-container: #242424;
+    --td-bg-color-container-hover: #383838;
+    --td-bg-color-container-active: #4c4c4c;
+    --td-bg-color-secondarycontainer: #2c2c2c;
+    --td-bg-color-component: #383838;
+    --td-bg-color-component-hover: #4c4c4c;
+    --td-bg-color-component-disabled: #383838;
+    
+    --td-border-color: #5e5e5e;
+    --td-border-color-light: #4c4c4c;
+    
+    --td-shadow-1: 0 1px 10px rgba(0, 0, 0, 0.15), 0 4px 5px rgba(0, 0, 0, 0.22), 0 2px 4px -1px rgba(0, 0, 0, 0.32);
+    --td-shadow-2: 0 3px 14px 2px rgba(0, 0, 0, 0.15), 0 8px 10px 1px rgba(0, 0, 0, 0.18), 0 5px 5px -3px rgba(0, 0, 0, 0.28);
+    --td-shadow-3: 0 6px 30px 5px rgba(0, 0, 0, 0.15), 0 16px 24px 2px rgba(0, 0, 0, 0.12), 0 8px 10px -5px rgba(0, 0, 0, 0.24);
+}
+
+/* ==================== 基础样式 ==================== */
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+html, body {
+    height: 100%;
+}
+
+body {
+    font-family: var(--td-font-family);
+    font-size: 14px;
+    line-height: 22px;
+    color: var(--td-text-color-primary);
+    background: var(--td-bg-color-page);
+    overflow: hidden;
+    transition: background-color var(--td-transition), color var(--td-transition);
+}
+
+/* 滚动条 */
+::-webkit-scrollbar {
+    width: 8px;
+    height: 8px;
+}
+
+::-webkit-scrollbar-track {
+    background: transparent;
+}
+
+::-webkit-scrollbar-thumb {
+    background: var(--td-border-color);
+    border-radius: 4px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+    background: var(--td-text-color-placeholder);
+}
+
+/* ==================== 布局 ==================== */
+.app {
+    display: flex;
+    height: 100vh;
+}
+
+/* ==================== 侧边栏 ==================== */
+.sidebar {
+    width: var(--sidebar-width);
+    background: var(--td-bg-color-container);
+    border-right: 1px solid var(--td-border-color-light);
+    display: flex;
+    flex-direction: column;
+    flex-shrink: 0;
+    transition: width var(--td-transition), background-color var(--td-transition), border-color var(--td-transition);
+}
+
+.sidebar.collapsed {
+    width: var(--sidebar-width-collapsed);
+}
+
+.logo {
+    height: 64px;
+    padding: 0 24px;
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    border-bottom: 1px solid var(--td-border-color-light);
+    flex-shrink: 0;
+}
+
+.sidebar.collapsed .logo {
+    padding: 0 16px;
+    justify-content: center;
+}
+
+.logo-icon {
+    width: 32px;
+    height: 32px;
+    background: linear-gradient(135deg, var(--td-brand-color), #618dff);
+    border-radius: var(--td-radius-default);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 18px;
+    color: white;
+}
+
+.logo-text {
+    font-size: 16px;
+    font-weight: 600;
+    color: var(--td-text-color-primary);
+    transition: opacity var(--td-transition);
+}
+
+.sidebar.collapsed .logo-text {
+    display: none;
+}
+
+
+.nav {
+    flex: 1;
+    padding: 12px 8px;
+    overflow-y: auto;
+    overflow-x: hidden;
+}
+
+.sidebar.collapsed .nav {
+    padding: 12px 4px;
+    overflow-x: hidden;
+}
+
+.nav-item {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    padding: 0 16px;
+    height: 40px;
+    border-radius: var(--td-radius-default);
+    color: var(--td-text-color-secondary);
+    text-decoration: none;
+    transition: all var(--td-transition);
+    margin-bottom: 2px;
+    font-size: 14px;
+    position: relative;
+}
+
+/* 侧边栏缩小时的 tooltip */
+.sidebar.collapsed .nav-item::after {
+    content: attr(title);
+    position: absolute;
+    left: 100%;
+    top: 50%;
+    transform: translateY(-50%);
+    margin-left: 12px;
+    padding: 6px 10px;
+    background: var(--td-text-color-primary);
+    color: var(--td-text-color-anti);
+    border-radius: var(--td-radius-small);
+    font-size: 12px;
+    white-space: nowrap;
+    opacity: 0;
+    pointer-events: none;
+    transition: opacity var(--td-transition);
+    z-index: 1000;
+    box-shadow: var(--td-shadow-2);
+}
+
+.sidebar.collapsed .nav-item:hover::after {
+    opacity: 1;
+}
+
+.sidebar.collapsed .nav-item {
+    padding: 0;
+    justify-content: center;
+    width: 40px;
+    margin: 0 auto 2px;
+}
+
+.sidebar.collapsed .nav-item span:last-child {
+    display: none;
+}
+
+.nav-item:hover {
+    background: var(--td-bg-color-container-hover);
+    color: var(--td-text-color-primary);
+}
+
+.nav-item.active {
+    background: var(--td-brand-color-light);
+    color: var(--td-brand-color);
+    font-weight: 500;
+}
+
+.nav-icon {
+    font-size: 16px;
+    width: 20px;
+    text-align: center;
+    opacity: 0.8;
+}
+
+.nav-item.active .nav-icon {
+    opacity: 1;
+}
+
+.sidebar-footer {
+    padding: 12px 16px;
+    border-top: 1px solid var(--td-border-color-light);
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+    flex-shrink: 0;
+    align-items: center;
+}
+
+.sidebar.collapsed .sidebar-footer {
+    padding: 12px 8px;
+    align-items: center;
+    justify-content: center;
+}
+
+.sidebar-footer-info {
+    display: flex;
+    flex-direction: column;
+    gap: 4px;
+    font-size: 12px;
+    color: var(--td-text-color-secondary);
+    align-items: center;
+    text-align: center;
+}
+
+.sidebar.collapsed .sidebar-footer-info {
+    display: none;
+}
+
+.sidebar-footer .version {
+    font-size: 12px;
+    color: var(--td-text-color-secondary);
+    font-family: var(--td-font-family-mono);
+}
+
+/* 缩小状态下显示版本号 */
+.sidebar.collapsed .sidebar-footer::before {
+    content: attr(data-version);
+    font-size: 11px;
+    color: var(--td-text-color-secondary);
+    font-family: var(--td-font-family-mono);
+    text-align: center;
+    display: block;
+}
+
+.sidebar-footer .cache-size {
+    font-size: 11px;
+    color: var(--td-text-color-placeholder);
+    font-family: var(--td-font-family-mono);
+}
+
+.version {
+    font-size: 12px;
+    color: var(--td-text-color-placeholder);
+    font-family: var(--td-font-family-mono);
+}
+
+/* 主题切换按钮 */
+.theme-toggle {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: 6px;
+    padding: 0 12px;
+    height: 32px;
+    border-radius: var(--td-radius-default);
+    font-size: 14px;
+    font-weight: 400;
+    border: 1px solid var(--td-border-color);
+    background: transparent;
+    color: var(--td-text-color-primary);
+    cursor: pointer;
+    transition: all var(--td-transition);
+    white-space: nowrap;
+}
+
+.theme-toggle:hover {
+    background: var(--td-bg-color-container-hover);
+    border-color: var(--td-text-color-secondary);
+}
+
+.theme-toggle span {
+    font-size: 14px;
+    line-height: 1;
+}
+
+/* ==================== 主内容区 ==================== */
+.main-content {
+    flex: 1;
+    overflow: hidden;
+    display: flex;
+    flex-direction: column;
+    background: var(--td-bg-color-page);
+}
+
+.page {
+    display: none;
+    flex-direction: column;
+    height: 100%;
+    overflow: hidden;
+}
+
+.page.active {
+    display: flex;
+}
+
+.page-header {
+    height: 64px;
+    padding: 0 32px;
+    flex-shrink: 0;
+    background: var(--td-bg-color-container);
+    border-bottom: 1px solid var(--td-border-color-light);
+    display: flex;
+    align-items: center;
+    gap: 16px;
+}
+
+.sidebar-toggle {
+    background: none;
+    border: none;
+    cursor: pointer;
+    padding: 8px;
+    border-radius: var(--td-radius-default);
+    transition: background-color var(--td-transition);
+    font-size: 18px;
+    line-height: 1;
+    color: var(--td-text-color-secondary);
+    flex-shrink: 0;
+    margin-top: 2px;
+}
+
+.sidebar-toggle:hover {
+    background: var(--td-bg-color-container-hover);
+    color: var(--td-text-color-primary);
+}
+
+.page-header-content {
+    flex: 1;
+    display: flex;
+    align-items: center;
+    gap: 16px;
+}
+
+.page-header .theme-toggle {
+    flex-shrink: 0;
+}
+
+.page-header h1 {
+    font-size: 20px;
+    font-weight: 600;
+    color: var(--td-text-color-primary);
+    margin: 0;
+    line-height: 1.2;
+}
+
+/* 页面头部操作按钮区域 */
+.page-header-actions {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    flex-shrink: 0;
+}
+
+/* 重启服务按钮 */
+.restart-btn {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 32px;
+    height: 32px;
+    border-radius: var(--td-radius-default);
+    font-size: 14px;
+    border: 1px solid #e34d59;
+    background: transparent;
+    color: #e34d59;
+    cursor: pointer;
+    transition: all var(--td-transition);
+}
+
+.restart-btn:hover {
+    background: #fdecee;
+    border-color: #e34d59;
+    color: #e34d59;
+}
+
+[data-theme="dark"] .restart-btn:hover {
+    background: #4b191d;
+}
+
+.restart-btn:active {
+    transform: scale(0.95);
+}
+
+.restart-btn span {
+    font-size: 14px;
+    line-height: 1;
+}
+
+.page-body {
+    flex: 1;
+    overflow-y: auto;
+    padding: 24px 32px;
+}
+
+/* ==================== 卡片 ==================== */
+.card {
+    background: var(--td-bg-color-container);
+    border-radius: var(--td-radius-large);
+    border: 1px solid var(--td-border-color-light);
+    transition: all var(--td-transition);
+}
+
+.card-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 16px 20px;
+    border-bottom: 1px solid var(--td-border-color-light);
+    font-size: 14px;
+    font-weight: 600;
+    color: var(--td-text-color-primary);
+}
+
+.card-header-left {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+}
+
+.card-header-right {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+}
+
+.card-title {
+    font-size: 14px;
+    font-weight: 600;
+    color: var(--td-text-color-primary);
+}
+
+.auto-refresh-toggle {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    font-size: 13px;
+    font-weight: normal;
+    color: var(--td-text-color-secondary);
+    cursor: pointer;
+    user-select: none;
+}
+
+.auto-refresh-toggle input[type="checkbox"] {
+    width: 16px;
+    height: 16px;
+    cursor: pointer;
+    accent-color: var(--td-brand-color);
+}
+
+.auto-refresh-toggle:hover {
+    color: var(--td-text-color-primary);
+}
+
+.card-body {
+    padding: 20px;
+}
+
+.card-footer {
+    padding: 12px 20px;
+    border-top: 1px solid var(--td-border-color-light);
+    background: var(--td-bg-color-secondarycontainer);
+    border-radius: 0 0 var(--td-radius-large) var(--td-radius-large);
+}
+
+/* ==================== 上传区域 ==================== */
+.upload-zone {
+    border: 1px dashed var(--td-border-color);
+    border-radius: var(--td-radius-large);
+    padding: 32px 24px;
+    text-align: center;
+    transition: all var(--td-transition);
+    cursor: pointer;
+    background: var(--td-bg-color-container);
+    position: relative;
+    min-height: 180px;
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
+    align-items: center;
+}
+
+.upload-zone:hover,
+.upload-zone.dragover {
+    border-color: var(--td-brand-color);
+    background: var(--td-brand-color-light);
+}
+
+.upload-zone.dragover {
+    border-style: solid;
+}
+
+.upload-icon {
+    width: 48px;
+    height: 48px;
+    margin: 0 auto 12px;
+    background: var(--td-brand-color-light);
+    border-radius: 50%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 24px;
+    color: var(--td-brand-color);
+}
+
+.upload-zone h3 {
+    font-size: 16px;
+    font-weight: 500;
+    margin-bottom: 8px;
+    color: var(--td-text-color-primary);
+}
+
+.upload-zone p {
+    color: var(--td-text-color-secondary);
+    font-size: 14px;
+    margin-bottom: 4px;
+}
+
+.upload-hint {
+    color: var(--td-brand-color) !important;
+    font-size: 13px !important;
+    margin-top: 12px !important;
+}
+
+.upload-zone input[type="file"] {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    opacity: 0;
+    cursor: pointer;
+}
+
+/* 文件列表 */
+.file-list {
+    margin-top: 20px;
+}
+
+.file-list-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 12px;
+}
+
+.file-list-header h4 {
+    font-size: 14px;
+    font-weight: 500;
+    color: var(--td-text-color-primary);
+}
+
+.file-items {
+    max-height: 240px;
+    overflow-y: auto;
+    border: 1px solid var(--td-border-color-light);
+    border-radius: var(--td-radius-default);
+    background: var(--td-bg-color-container);
+}
+
+.file-item {
+    display: flex;
+    align-items: center;
+    padding: 10px 16px;
+    font-size: 13px;
+    color: var(--td-text-color-primary);
+    border-bottom: 1px solid var(--td-border-color-light);
+    transition: background var(--td-transition);
+    position: relative;
+    flex-wrap: wrap;
+}
+
+.file-item:last-child {
+    border-bottom: none;
+}
+
+.file-item:hover {
+    background: var(--td-bg-color-container-hover);
+}
+
+.file-item.uploading {
+    background: var(--td-brand-color-light);
+}
+
+.file-item.uploaded {
+    background: var(--td-success-color-light);
+}
+
+.file-item.error {
+    background: var(--td-error-color-light);
+}
+
+.file-item-icon {
+    margin-right: 10px;
+    font-size: 16px;
+    flex-shrink: 0;
+}
+
+.file-item-name {
+    flex: 1;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    font-family: var(--td-font-family-mono);
+    font-size: 12px;
+    min-width: 0;
+}
+
+.file-item-size {
+    color: var(--td-text-color-placeholder);
+    font-size: 12px;
+    font-family: var(--td-font-family-mono);
+    margin-left: 8px;
+    flex-shrink: 0;
+}
+
+.file-item-status {
+    font-size: 12px;
+    margin-left: 12px;
+    flex-shrink: 0;
+    display: flex;
+    align-items: center;
+    gap: 6px;
+}
+
+.file-item-status.pending {
+    color: var(--td-text-color-placeholder);
+}
+
+.file-item-status.uploading {
+    color: var(--td-brand-color);
+    font-weight: 500;
+}
+
+.file-item-status.uploaded {
+    color: var(--td-success-color);
+}
+
+.file-item-status.error {
+    color: var(--td-error-color);
+}
+
+/* 进度条 */
+.file-progress {
+    width: 100%;
+    height: 3px;
+    background: var(--td-bg-color-component);
+    border-radius: 2px;
+    margin-top: 8px;
+    overflow: hidden;
+}
+
+.file-progress-bar {
+    height: 100%;
+    background: var(--td-brand-color);
+    border-radius: 2px;
+    transition: width 0.2s ease;
+    width: 0%;
+}
+
+.file-item.uploaded .file-progress-bar {
+    background: var(--td-success-color);
+}
+
+.file-item.error .file-progress-bar {
+    background: var(--td-error-color);
+}
+
+/* 上传统计 */
+.upload-stats {
+    display: flex;
+    align-items: center;
+    gap: 16px;
+    margin-bottom: 12px;
+    padding: 12px 16px;
+    background: var(--td-bg-color-secondarycontainer);
+    border-radius: var(--td-radius-default);
+    font-size: 13px;
+}
+
+.upload-stats-item {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+}
+
+.upload-stats-item .count {
+    font-weight: 600;
+    color: var(--td-text-color-primary);
+}
+
+.upload-stats-item.uploading .count {
+    color: var(--td-brand-color);
+}
+
+.upload-stats-item.success .count {
+    color: var(--td-success-color);
+}
+
+.upload-stats-item.error .count {
+    color: var(--td-error-color);
+}
+
+/* 总进度条 */
+.total-progress {
+    margin-bottom: 16px;
+}
+
+.total-progress-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 8px;
+    font-size: 13px;
+}
+
+.total-progress-header .label {
+    color: var(--td-text-color-secondary);
+}
+
+.total-progress-header .percent {
+    font-weight: 600;
+    color: var(--td-brand-color);
+}
+
+.total-progress-bar {
+    height: 6px;
+    background: var(--td-bg-color-component);
+    border-radius: 3px;
+    overflow: hidden;
+}
+
+.total-progress-bar-inner {
+    height: 100%;
+    background: linear-gradient(90deg, var(--td-brand-color), #618dff);
+    border-radius: 3px;
+    transition: width 0.3s ease;
+    width: 0%;
+}
+
+.file-list-footer {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-top: 16px;
+}
+
+#fileCount {
+    color: var(--td-text-color-secondary);
+    font-size: 13px;
+}
+
+/* ==================== 处理区域 ==================== */
+.process-section {
+    margin-top: 24px;
+}
+
+.process-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.process-status {
+    font-size: 12px;
+    padding: 4px 12px;
+    border-radius: 10px;
+    background: var(--td-brand-color);
+    color: white;
+    font-weight: 500;
+}
+
+.process-status.processing {
+    animation: pulse 1.5s infinite;
+}
+
+.process-status.completed {
+    background: var(--td-success-color);
+}
+
+.process-status.failed {
+    background: var(--td-error-color);
+}
+
+@keyframes pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.6; }
+}
+
+.log-container {
+    height: calc(100vh - 280px);
+    min-height: 400px;
+    max-height: 600px;
+    overflow-y: auto;
+    background: var(--td-bg-color-page);
+    border-radius: var(--td-radius-default);
+    padding: 16px;
+    margin-top: 16px;
+    border: 1px solid var(--td-border-color-light);
+}
+
+.log-content {
+    font-family: var(--td-font-family-mono);
+    font-size: 12px;
+    line-height: 1.8;
+}
+
+.log-line {
+    padding: 2px 0;
+    color: var(--td-text-color-secondary);
+}
+
+.log-line.info { color: var(--td-text-color-secondary); }
+.log-line.success { color: var(--td-success-color); }
+.log-line.error { color: var(--td-error-color); }
+.log-line.warn { color: var(--td-warning-color); }
+
+.process-actions {
+    display: flex;
+    gap: 12px;
+    margin-top: 16px;
+}
+
+/* ==================== 历史记录 ==================== */
+.toolbar {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    gap: 12px;
+    margin-bottom: 16px;
+}
+
+.total-size {
+    font-size: 13px;
+    color: var(--td-text-color-secondary);
+    font-family: var(--td-font-family-mono);
+}
+
+.history-list {
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+}
+
+.history-item {
+    background: var(--td-bg-color-container);
+    border: 1px solid var(--td-border-color-light);
+    border-radius: var(--td-radius-default);
+    padding: 16px 20px;
+    display: flex;
+    align-items: center;
+    gap: 16px;
+    transition: all var(--td-transition);
+}
+
+.history-item:hover {
+    border-color: var(--td-brand-color);
+    box-shadow: var(--td-shadow-1);
+}
+
+.history-status {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    flex-shrink: 0;
+}
+
+.history-status.completed { background: var(--td-success-color); }
+.history-status.failed { background: var(--td-error-color); }
+.history-status.processing {
+    background: var(--td-brand-color);
+    animation: pulse 1s infinite;
+}
+.history-status.pending { background: var(--td-text-color-placeholder); }
+
+.history-info {
+    flex: 1;
+}
+
+.history-id {
+    font-family: var(--td-font-family-mono);
+    font-size: 14px;
+    font-weight: 500;
+    color: var(--td-text-color-primary);
+    margin-bottom: 4px;
+}
+
+.history-meta {
+    font-size: 12px;
+    color: var(--td-text-color-placeholder);
+}
+
+.record-size {
+    font-family: var(--td-font-family-mono);
+    color: var(--td-text-color-secondary);
+}
+
+.history-actions {
+    display: flex;
+    gap: 8px;
+}
+
+/* ==================== 数据库管理 ==================== */
+.database-layout {
+    display: flex;
+    gap: 20px;
+    height: 100%;
+}
+
+.db-sidebar {
+    width: 240px;
+    flex-shrink: 0;
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+}
+
+.db-connection {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    padding: 12px 16px;
+    background: var(--td-bg-color-container);
+    border-radius: var(--td-radius-default);
+    border: 1px solid var(--td-border-color-light);
+    font-size: 13px;
+    color: var(--td-text-color-secondary);
+}
+
+.status-dot {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    background: var(--td-text-color-placeholder);
+}
+
+.status-dot.connected { background: var(--td-success-color); }
+.status-dot.error { background: var(--td-error-color); }
+
+.table-list {
+    flex: 1;
+    background: var(--td-bg-color-container);
+    border-radius: var(--td-radius-default);
+    border: 1px solid var(--td-border-color-light);
+    overflow-y: auto;
+}
+
+.table-item {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    padding: 10px 16px;
+    cursor: pointer;
+    transition: all var(--td-transition);
+    border-bottom: 1px solid var(--td-border-color-light);
+    font-size: 13px;
+    color: var(--td-text-color-primary);
+}
+
+.table-item:last-child { border-bottom: none; }
+
+.table-item:hover {
+    background: var(--td-bg-color-container-hover);
+}
+
+.table-item.active {
+    background: var(--td-brand-color-light);
+    color: var(--td-brand-color);
+    font-weight: 500;
+}
+
+.table-icon {
+    opacity: 0.6;
+    font-size: 14px;
+}
+
+.db-content {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    min-width: 0;
+    overflow: hidden;
+    background: var(--td-bg-color-container);
+    border-radius: var(--td-radius-default);
+    border: 1px solid var(--td-border-color-light);
+}
+
+.db-toolbar {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 12px 16px;
+    border-bottom: 1px solid var(--td-border-color-light);
+    background: var(--td-bg-color-secondarycontainer);
+}
+
+.toolbar-left {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+}
+
+.current-table {
+    font-weight: 600;
+    font-size: 14px;
+    color: var(--td-text-color-primary);
+}
+
+.row-count {
+    font-size: 12px;
+    color: var(--td-text-color-placeholder);
+    background: var(--td-bg-color-component);
+    padding: 2px 8px;
+    border-radius: 10px;
+}
+
+.toolbar-right {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+}
+
+.search-input {
+    padding: 6px 12px;
+    background: var(--td-bg-color-container);
+    border: 1px solid var(--td-border-color);
+    border-radius: var(--td-radius-default);
+    color: var(--td-text-color-primary);
+    font-size: 13px;
+    width: 180px;
+    transition: all var(--td-transition);
+    outline: none;
+}
+
+.search-input::placeholder {
+    color: var(--td-text-color-placeholder);
+}
+
+.search-input:focus {
+    border-color: var(--td-brand-color);
+    box-shadow: 0 0 0 2px var(--td-brand-color-focus);
+}
+
+.data-table-container {
+    flex: 1;
+    overflow: auto;
+}
+
+.data-table {
+    width: 100%;
+    border-collapse: collapse;
+    font-size: 13px;
+}
+
+.data-table th {
+    position: sticky;
+    top: 0;
+    background: var(--td-bg-color-secondarycontainer);
+    padding: 10px 16px;
+    text-align: left;
+    font-weight: 500;
+    color: var(--td-text-color-secondary);
+    border-bottom: 1px solid var(--td-border-color-light);
+    white-space: nowrap;
+    font-size: 12px;
+}
+
+.data-table td {
+    padding: 10px 16px;
+    border-bottom: 1px solid var(--td-border-color-light);
+    color: var(--td-text-color-primary);
+    max-width: 200px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.data-table tr:hover td {
+    background: var(--td-bg-color-container-hover);
+}
+
+.pagination {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    gap: 12px;
+    padding: 12px 16px;
+    border-top: 1px solid var(--td-border-color-light);
+    background: var(--td-bg-color-secondarycontainer);
+}
+
+#pageInfo {
+    font-size: 13px;
+    color: var(--td-text-color-secondary);
+}
+
+/* ==================== 设置页面 ==================== */
+.settings-page-body {
+    display: grid;
+    grid-template-columns: 1fr 1.5fr;
+    gap: 20px;
+    padding-bottom: 40px;
+}
+
+.settings-column {
+    display: flex;
+    flex-direction: column;
+    gap: 20px;
+}
+
+.settings-column-wide {
+    min-width: 0;
+}
+
+.settings-card .card-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.config-update-time,
+.field-count {
+    font-size: 12px;
+    color: var(--td-text-color-placeholder);
+}
+
+.settings-card .card-body {
+    padding: 16px 20px;
+}
+
+.settings-card .card-footer {
+    display: flex;
+    gap: 12px;
+    padding: 12px 20px;
+    border-top: 1px solid var(--td-border-color-light);
+    background: var(--td-bg-color-container);
+}
+
+/* 表单布局 */
+.form-row {
+    display: flex;
+    gap: 12px;
+    margin-bottom: 12px;
+}
+
+.form-row:last-child {
+    margin-bottom: 0;
+}
+
+.form-group {
+    display: flex;
+    flex-direction: column;
+    gap: 6px;
+    flex: 1;
+    margin-bottom: 12px;
+}
+
+.form-group:last-child {
+    margin-bottom: 0;
+}
+
+.form-row .form-group {
+    margin-bottom: 0;
+}
+
+.form-group-sm {
+    flex: 0 0 100px;
+}
+
+.form-group label {
+    font-size: 13px;
+    color: var(--td-text-color-secondary);
+}
+
+.form-hint {
+    font-size: 12px;
+    color: var(--td-text-color-placeholder);
+    margin: 0 0 12px 0;
+}
+
+.form-input {
+    height: 32px;
+    padding: 0 12px;
+    border: 1px solid var(--td-border-color);
+    border-radius: var(--td-radius-default);
+    font-size: 14px;
+    background: var(--td-bg-color-container);
+    color: var(--td-text-color-primary);
+    transition: all var(--td-transition);
+    width: 100%;
+    box-sizing: border-box;
+}
+
+.form-input:focus {
+    border-color: var(--td-brand-color);
+    outline: none;
+    box-shadow: 0 0 0 2px var(--td-brand-color-focus);
+}
+
+.form-input::placeholder {
+    color: var(--td-text-color-placeholder);
+}
+
+/* 密码输入框 */
+.password-input-wrapper {
+    position: relative;
+    display: flex;
+    align-items: center;
+}
+
+.password-input-wrapper .form-input {
+    padding-right: 36px;
+}
+
+.password-toggle {
+    position: absolute;
+    right: 4px;
+    width: 28px;
+    height: 28px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: transparent;
+    border: none;
+    cursor: pointer;
+    border-radius: var(--td-radius-small);
+    color: var(--td-text-color-placeholder);
+    transition: all var(--td-transition);
+}
+
+.password-toggle:hover {
+    background: var(--td-bg-color-component-hover);
+    color: var(--td-text-color-secondary);
+}
+
+.password-toggle .eye-icon {
+    font-size: 14px;
+    line-height: 1;
+}
+
+/* Sheet 过滤规则 */
+.filter-list {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 8px;
+    margin-bottom: 12px;
+    min-height: 28px;
+}
+
+.filter-item {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    padding: 4px 8px 4px 10px;
+    background: var(--td-bg-color-secondarycontainer);
+    border-radius: var(--td-radius-default);
+    font-size: 13px;
+}
+
+.filter-item .filter-text {
+    color: var(--td-text-color-primary);
+}
+
+.filter-item .remove-filter {
+    cursor: pointer;
+    color: var(--td-text-color-placeholder);
+    font-size: 12px;
+    background: none;
+    border: none;
+    padding: 0;
+    line-height: 1;
+}
+
+.filter-item .remove-filter:hover {
+    color: var(--td-error-color);
+}
+
+.add-filter-row {
+    display: flex;
+    gap: 8px;
+}
+
+.add-filter-row .form-input {
+    flex: 1;
+}
+
+.empty-hint {
+    color: var(--td-text-color-placeholder);
+    font-size: 13px;
+    padding: 8px 0;
+}
+
+/* 字段映射配置 */
+.field-mapping-card {
+    height: fit-content;
+}
+
+.field-mapping-card .card-body {
+    max-height: calc(100vh - 280px);
+    overflow-y: auto;
+    padding: 12px 16px;
+}
+
+.field-mapping-list {
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+}
+
+.field-mapping-item {
+    position: relative;
+    padding: 12px 14px;
+    background: var(--td-bg-color-container);
+    border: 1px solid var(--td-border-color);
+    border-radius: var(--td-radius-default);
+    box-shadow: 0 1px 2px rgba(0, 0, 0, 0.05);
+    transition: box-shadow var(--td-transition);
+}
+
+.field-mapping-item:hover {
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.08);
+}
+
+.field-mapping-number {
+    position: absolute;
+    top: 4px;
+    left: 4px;
+    width: 20px;
+    height: 20px;
+    background: var(--td-brand-color);
+    color: white;
+    border-radius: var(--td-radius-small);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 11px;
+    font-weight: 600;
+    z-index: 1;
+    box-shadow: 0 1px 2px rgba(0, 0, 0, 0.1);
+}
+
+.field-mapping-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding-bottom: 10px;
+    border-bottom: 1px solid var(--td-border-color-light);
+    margin-bottom: 10px;
+}
+
+.field-name {
+    flex: 1;
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    padding-left: 28px;
+}
+
+.field-name label {
+    font-size: 13px;
+    color: var(--td-text-color-secondary);
+    white-space: nowrap;
+    font-weight: 500;
+}
+
+.field-name .field-input {
+    flex: 0 0 75%;
+    max-width: 75%;
+    height: 28px;
+    font-size: 13px;
+}
+
+.extract-list {
+    display: flex;
+    flex-direction: column;
+}
+
+.extract-list > label {
+    font-size: 12px;
+    color: var(--td-text-color-primary);
+    font-weight: 500;
+    margin-bottom: 8px;
+}
+
+/* 提取来源列表 - 树状显示 */
+.extract-tree {
+    max-height: 120px;
+    overflow-y: auto;
+    border: 1px solid var(--td-border-color-light);
+    border-radius: var(--td-radius-small);
+    background: var(--td-bg-color-secondarycontainer);
+    margin-bottom: 8px;
+}
+
+.extract-tree:empty {
+    display: none;
+}
+
+.extract-tree-item {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 6px 10px;
+    font-size: 13px;
+    color: var(--td-text-color-primary);
+    border-bottom: 1px solid var(--td-border-color-light);
+    transition: background var(--td-transition);
+}
+
+.extract-tree-item:last-child {
+    border-bottom: none;
+}
+
+.extract-tree-item:hover {
+    background: var(--td-bg-color-container-hover);
+}
+
+.extract-tree-item .tree-text {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+}
+
+.extract-tree-item .tree-text::before {
+    content: "└";
+    color: var(--td-text-color-placeholder);
+    font-size: 12px;
+}
+
+.extract-tree-item .tree-remove {
+    cursor: pointer;
+    font-size: 12px;
+    color: var(--td-warning-color);
+    background: none;
+    border: none;
+    padding: 2px 6px;
+    border-radius: var(--td-radius-small);
+    transition: all var(--td-transition);
+}
+
+.extract-tree-item .tree-remove:hover {
+    color: var(--td-warning-color);
+    background: var(--td-warning-color-light);
+}
+
+.extract-empty {
+    padding: 12px;
+    text-align: center;
+    color: var(--td-text-color-placeholder);
+    font-size: 12px;
+    border: 1px dashed var(--td-border-color);
+    border-radius: var(--td-radius-small);
+    margin-bottom: 8px;
+}
+
+.add-extract-row {
+    display: flex;
+    gap: 8px;
+    justify-content: flex-end;
+}
+
+.add-extract-row .extract-input {
+    flex: 0 0 75%;
+    height: 28px;
+    font-size: 13px;
+}
+
+.btn-icon {
+    width: 28px;
+    height: 28px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border: none;
+    background: transparent;
+    cursor: pointer;
+    border-radius: var(--td-radius-small);
+    font-size: 14px;
+    color: var(--td-text-color-secondary);
+    transition: all var(--td-transition);
+    flex-shrink: 0;
+}
+
+.btn-icon:hover {
+    background: var(--td-bg-color-component-hover);
+    color: var(--td-error-color);
+}
+
+.btn-icon.remove-mapping {
+    color: var(--td-error-color);
+}
+
+.btn-icon.remove-mapping:hover {
+    background: var(--td-error-color-light);
+    color: var(--td-error-color);
+}
+
+/* 设置项样式（主题设置卡片） */
+.settings-item {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 8px 0;
+}
+
+.settings-item label {
+    color: var(--td-text-color-secondary);
+    font-size: 14px;
+}
+
+.settings-item span {
+    font-size: 14px;
+    color: var(--td-text-color-primary);
+}
+
+/* 响应式 */
+@media (max-width: 1024px) {
+    .settings-page-body {
+        grid-template-columns: 1fr;
+    }
+}
+
+/* ==================== 按钮 ==================== */
+.btn {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: 6px;
+    padding: 0 16px;
+    height: 32px;
+    border-radius: var(--td-radius-default);
+    font-size: 14px;
+    font-weight: 400;
+    border: 1px solid transparent;
+    cursor: pointer;
+    transition: all var(--td-transition);
+    text-decoration: none;
+    white-space: nowrap;
+}
+
+.btn-sm {
+    height: 28px;
+    padding: 0 12px;
+    font-size: 13px;
+}
+
+.btn-lg {
+    height: 40px;
+    padding: 0 24px;
+    font-size: 14px;
+}
+
+.btn-primary {
+    background: var(--td-brand-color);
+    color: white;
+    border-color: var(--td-brand-color);
+}
+
+.btn-primary:hover {
+    background: var(--td-brand-color-hover);
+    border-color: var(--td-brand-color-hover);
+}
+
+.btn-primary:active {
+    background: var(--td-brand-color-active);
+}
+
+.btn-success {
+    background: var(--td-success-color);
+    color: white;
+    border-color: var(--td-success-color);
+}
+
+.btn-success:hover {
+    filter: brightness(1.1);
+}
+
+.btn-warning {
+    background: var(--td-warning-color);
+    color: white;
+    border-color: var(--td-warning-color);
+}
+
+.btn-warning:hover {
+    filter: brightness(1.1);
+}
+
+.btn-danger {
+    background: var(--td-error-color);
+    color: white;
+    border-color: var(--td-error-color);
+}
+
+.btn-danger:hover {
+    filter: brightness(1.1);
+}
+
+.btn-outline {
+    background: var(--td-bg-color-container);
+    color: var(--td-text-color-primary);
+    border-color: var(--td-border-color);
+}
+
+.btn-outline:hover {
+    background: var(--td-bg-color-container-hover);
+    border-color: var(--td-text-color-secondary);
+}
+
+.add-extract {
+    background: var(--td-brand-color-light);
+    color: var(--td-brand-color);
+    border-color: var(--td-brand-color-light);
+}
+
+.add-extract:hover {
+    background: var(--td-brand-color);
+    color: white;
+    border-color: var(--td-brand-color);
+}
+
+.btn-text {
+    background: transparent;
+    color: var(--td-brand-color);
+    border-color: transparent;
+    padding: 0 8px;
+}
+
+.btn-text:hover {
+    background: var(--td-brand-color-light);
+}
+
+.btn:disabled {
+    opacity: 0.4;
+    cursor: not-allowed;
+}
+
+/* ==================== 空状态 ==================== */
+.empty-state {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    padding: 64px 24px;
+    color: var(--td-text-color-placeholder);
+}
+
+.empty-icon {
+    font-size: 48px;
+    margin-bottom: 16px;
+    opacity: 0.4;
+}
+
+.empty-state p {
+    font-size: 14px;
+}
+
+.loading {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    padding: 40px;
+    color: var(--td-text-color-secondary);
+    font-size: 14px;
+}
+
+/* ==================== Toast 通知 ==================== */
+.toast-container {
+    position: fixed;
+    top: 80px;
+    right: 16px;
+    z-index: 9999;
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+}
+
+.toast {
+    padding: 12px 16px;
+    border-radius: var(--td-radius-default);
+    background: var(--td-bg-color-container);
+    border: 1px solid var(--td-border-color-light);
+    box-shadow: var(--td-shadow-2);
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    font-size: 14px;
+    animation: toastIn 0.3s ease;
+    min-width: 280px;
+    color: var(--td-text-color-primary);
+}
+
+@keyframes toastIn {
+    from {
+        transform: translateX(100%);
+        opacity: 0;
+    }
+    to {
+        transform: translateX(0);
+        opacity: 1;
+    }
+}
+
+.toast-icon {
+    width: 20px;
+    height: 20px;
+    border-radius: 50%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 12px;
+    color: white;
+}
+
+.toast.success .toast-icon { background: var(--td-success-color); }
+.toast.error .toast-icon { background: var(--td-error-color); }
+.toast.warning .toast-icon { background: var(--td-warning-color); }
+.toast.info .toast-icon { background: var(--td-info-color); }
+
+/* ==================== 模态框 ==================== */
+.modal {
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    z-index: 9000;
+    display: none;
+    align-items: center;
+    justify-content: center;
+}
+
+.modal.active {
+    display: flex;
+}
+
+.modal-backdrop {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background: var(--td-mask-color);
+    backdrop-filter: blur(2px);
+}
+
+.modal-content {
+    position: relative;
+    background: var(--td-bg-color-container);
+    border-radius: var(--td-radius-large);
+    padding: 24px;
+    min-width: 400px;
+    max-width: 90%;
+    max-height: 90vh;
+    overflow-y: auto;
+    box-shadow: var(--td-shadow-3);
+}
+
+.modal-content h3 {
+    font-size: 16px;
+    font-weight: 600;
+    margin-bottom: 12px;
+    color: var(--td-text-color-primary);
+}
+
+.modal-content p {
+    color: var(--td-text-color-secondary);
+    margin-bottom: 20px;
+    font-size: 14px;
+}
+
+.modal-actions {
+    display: flex;
+    justify-content: flex-end;
+    gap: 12px;
+}
+
+.download-options {
+    display: flex;
+    flex-direction: column;
+    gap: 10px;
+    margin-bottom: 20px;
+}
+
+.download-option {
+    justify-content: flex-start;
+    height: 48px;
+}
+
+/* ==================== 重启服务加载遮罩 ==================== */
+.restart-overlay {
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    z-index: 10000;
+    display: none;
+    align-items: center;
+    justify-content: center;
+    background: var(--td-mask-color);
+    backdrop-filter: blur(4px);
+}
+
+.restart-overlay.active {
+    display: flex;
+}
+
+.restart-overlay-content {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 20px;
+    padding: 40px 60px;
+    background: var(--td-bg-color-container);
+    border-radius: var(--td-radius-large);
+    box-shadow: var(--td-shadow-3);
+}
+
+.restart-overlay-spinner {
+    width: 48px;
+    height: 48px;
+    border: 4px solid var(--td-border-color-light);
+    border-top-color: var(--td-brand-color);
+    border-radius: 50%;
+    animation: spinner-rotate 1s linear infinite;
+}
+
+@keyframes spinner-rotate {
+    from { transform: rotate(0deg); }
+    to { transform: rotate(360deg); }
+}
+
+.restart-overlay-text {
+    font-size: 16px;
+    font-weight: 500;
+    color: var(--td-text-color-primary);
+    text-align: center;
+}
+
+/* ==================== 响应式 ==================== */
+@media (max-width: 1200px) {
+    .database-layout {
+        flex-direction: column;
+    }
+    
+    .db-sidebar {
+        width: 100%;
+        flex-direction: row;
+    }
+    
+    .table-list {
+        flex: 1;
+        max-height: 180px;
+    }
+}
+
+@media (max-width: 768px) {
+    .sidebar {
+        width: 64px;
+    }
+    
+.logo-text,
+.nav-item span:last-child {
+    display: none;
+}
+    
+    .logo {
+        justify-content: center;
+        padding: 0 16px;
+    }
+    
+    .nav-item {
+        justify-content: center;
+        padding: 0;
+        width: 40px;
+        margin: 0 auto 2px;
+    }
+    
+    .nav-icon {
+        margin: 0;
+    }
+    
+    
+    .page-header,
+    .page-body {
+        padding-left: 20px;
+        padding-right: 20px;
+    }
+    
+    .settings-grid {
+        grid-template-columns: 1fr;
+    }
+}
diff --git a/static/index.html b/static/index.html
new file mode 100644
index 0000000..a81941b
--- /dev/null
+++ b/static/index.html
@@ -0,0 +1,414 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>容量报表处理程序</title>
+    <link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><text y='.9em' font-size='90'>📊</text></svg>">
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Noto+Sans+SC:wght@400;500;600;700&display=swap" rel="stylesheet">
+    <link rel="stylesheet" href="/static/css/style.css">
+</head>
+<body>
+    <div class="app">
+        <!-- 侧边栏导航 -->
+        <aside class="sidebar" id="sidebar">
+            <div class="logo">
+                <div class="logo-icon">📊</div>
+                <span class="logo-text">CapacityReport</span>
+            </div>
+            <nav class="nav">
+                <a href="#" class="nav-item active" data-page="upload" title="数据上传">
+                    <span class="nav-icon">📤</span>
+                    <span>数据上传</span>
+                </a>
+                <a href="#" class="nav-item" data-page="history" title="处理历史">
+                    <span class="nav-icon">📋</span>
+                    <span>处理历史</span>
+                </a>
+                <a href="#" class="nav-item" data-page="database" title="数据库管理">
+                    <span class="nav-icon">🗄️</span>
+                    <span>数据库管理</span>
+                </a>
+                <a href="#" class="nav-item" data-page="settings" title="系统设置">
+                    <span class="nav-icon">⚙️</span>
+                    <span>系统设置</span>
+                </a>
+            </nav>
+            <div class="sidebar-footer" data-version="v2.0.0">
+                <div class="sidebar-footer-info">
+                    <span class="version">版本：v2.0.0</span>
+                    <span class="version">Power by：NIXEVOL</span>
+                </div>
+            </div>
+        </aside>
+
+        <!-- 主内容区 -->
+        <main class="main-content">
+            <!-- 上传页面 -->
+            <section id="page-upload" class="page active">
+                <header class="page-header">
+                    <button class="sidebar-toggle" id="sidebarToggle" title="展开/收起侧边栏">
+                        <span id="sidebarToggleIcon">☰</span>
+                    </button>
+                    <div class="page-header-content">
+                        <h1>数据上传与处理</h1>
+                    </div>
+                    <div class="page-header-actions">
+                        <button class="theme-toggle" id="themeToggle" title="切换主题">
+                            <span>🌓</span>
+                        </button>
+                        <button class="restart-btn" id="restartService" title="重启服务">
+                            <span>⏻</span>
+                        </button>
+                    </div>
+                </header>
+
+                <div class="page-body">
+                    <div class="upload-zone" id="uploadZone">
+                        <div class="upload-icon">📁</div>
+                        <h3>拖拽文件夹或文件到这里</h3>
+                        <p>支持 .zip, .xlsx, .xls, .csv 格式</p>
+                        <p class="upload-hint">或者点击选择文件</p>
+                        <input type="file" id="fileInput" multiple webkitdirectory directory>
+                        <input type="file" id="fileInputSingle" multiple accept=".zip,.xlsx,.xls,.csv" style="display:none">
+                    </div>
+
+                    <div class="file-list" id="fileList" style="display: none;">
+                        <div class="file-list-header">
+                            <h4>已选择文件</h4>
+                            <button class="btn btn-sm btn-text" id="clearFiles">清空</button>
+                        </div>
+                        
+                        <div class="file-list-footer">
+                            <span id="fileCount">0 个文件</span>
+                            <button class="btn btn-primary" id="startUpload">
+                                <span>🚀</span> 上传并处理
+                            </button>
+                        </div>
+                        
+                        <!-- 总进度 -->
+                        <div class="total-progress" id="totalProgress" style="display: none; padding: 16px;">
+                            <div class="total-progress-header">
+                                <span class="label">上传进度</span>
+                                <span class="percent" id="totalPercent">0%</span>
+                            </div>
+                            <div class="total-progress-bar">
+                                <div class="total-progress-bar-inner" id="totalProgressBar"></div>
+                            </div>
+                        </div>
+                        
+                        <!-- 上传统计 -->
+                        <div class="upload-stats" id="uploadStats" style="display: none; margin: 0 16px;">
+                            <div class="upload-stats-item">
+                                <span>总计:</span>
+                                <span class="count" id="statsTotal">0</span>
+                            </div>
+                            <div class="upload-stats-item uploading">
+                                <span>上传中:</span>
+                                <span class="count" id="statsUploading">0</span>
+                            </div>
+                            <div class="upload-stats-item success">
+                                <span>已完成:</span>
+                                <span class="count" id="statsSuccess">0</span>
+                            </div>
+                            <div class="upload-stats-item error">
+                                <span>失败:</span>
+                                <span class="count" id="statsError">0</span>
+                            </div>
+                        </div>
+                        
+                        <div class="file-items" id="fileItems"></div>
+                    </div>
+
+                    <!-- 处理状态 -->
+                    <div class="process-section" id="processSection" style="display: none;">
+                        <div class="card">
+                            <div class="card-header">
+                                <div class="card-header-left">
+                                    <span class="card-title">处理进度</span>
+                                    <span class="process-status processing" id="processStatus">处理中...</span>
+                                </div>
+                                <div class="card-header-right">
+                                    <label class="auto-refresh-toggle">
+                                        <input type="checkbox" id="autoRefreshLog" checked>
+                                        <span>自动刷新</span>
+                                    </label>
+                                    <button class="btn btn-sm btn-outline" id="manualRefreshLog" title="手动刷新日志">
+                                        <span>🔄</span>
+                                    </button>
+                                </div>
+                            </div>
+                            <div class="card-body">
+                                <div class="log-container" id="logContainer">
+                                    <div class="log-content" id="logContent"></div>
+                                </div>
+                            </div>
+                            <div class="card-footer process-actions" id="processActions" style="display: none;">
+                                <button class="btn btn-success" id="downloadResult">
+                                    <span>📥</span> 下载结果
+                                </button>
+                                <button class="btn btn-outline" id="newProcess">
+                                    <span>🔄</span> 新建任务
+                                </button>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </section>
+
+            <!-- 历史记录页面 -->
+            <section id="page-history" class="page">
+                <header class="page-header">
+                    <button class="sidebar-toggle" id="sidebarToggle" title="展开/收起侧边栏">
+                        <span id="sidebarToggleIcon">☰</span>
+                    </button>
+                    <div class="page-header-content">
+                        <h1>处理历史</h1>
+                    </div>
+                    <div class="page-header-actions">
+                        <button class="theme-toggle" id="themeToggle" title="切换主题">
+                            <span>🌓</span>
+                        </button>
+                        <button class="restart-btn" id="restartService" title="重启服务">
+                            <span>⏻</span>
+                        </button>
+                    </div>
+                </header>
+                <div class="page-body">
+                    <div class="toolbar">
+                        <div class="toolbar-left">
+                            <button class="btn btn-outline" id="refreshHistory">
+                                <span>🔄</span> 刷新
+                            </button>
+                            <button class="btn btn-danger" id="clearHistory">
+                                <span>🗑️</span> 清空历史
+                            </button>
+                        </div>
+                        <div class="toolbar-right">
+                            <span class="total-size">总占用: <span id="totalHistorySize">计算中...</span></span>
+                        </div>
+                    </div>
+                    <div class="history-list" id="historyList">
+                        <div class="empty-state">
+                            <span class="empty-icon">📭</span>
+                            <p>暂无处理记录</p>
+                        </div>
+                    </div>
+                </div>
+            </section>
+
+            <!-- 数据库管理页面 -->
+            <section id="page-database" class="page">
+                <header class="page-header">
+                    <button class="sidebar-toggle" id="sidebarToggle" title="展开/收起侧边栏">
+                        <span id="sidebarToggleIcon">☰</span>
+                    </button>
+                    <div class="page-header-content">
+                        <h1>数据库管理</h1>
+                    </div>
+                    <div class="page-header-actions">
+                        <button class="theme-toggle" id="themeToggle" title="切换主题">
+                            <span>🌓</span>
+                        </button>
+                        <button class="restart-btn" id="restartService" title="重启服务">
+                            <span>⏻</span>
+                        </button>
+                    </div>
+                </header>
+                <div class="page-body" style="display: flex; flex-direction: column; height: calc(100% - 64px);">
+                    <div class="database-layout" style="flex: 1; overflow: hidden;">
+                        <div class="db-sidebar">
+                            <div class="db-connection" id="dbConnection">
+                                <span class="status-dot"></span>
+                                <span>检测连接中...</span>
+                            </div>
+                            <div class="table-list" id="tableList">
+                                <div class="loading">加载中...</div>
+                            </div>
+                        </div>
+                        <div class="db-content">
+                            <div class="db-toolbar" id="dbToolbar" style="display: none;">
+                                <div class="toolbar-left">
+                                    <span class="current-table" id="currentTable"></span>
+                                    <span class="row-count" id="rowCount"></span>
+                                </div>
+                                <div class="toolbar-right">
+                                    <input type="text" class="search-input" id="searchInput" placeholder="搜索...">
+                                    <button class="btn btn-sm btn-primary" id="downloadTable">📥 导出</button>
+                                    <button class="btn btn-sm btn-warning" id="truncateTable">清空</button>
+                                    <button class="btn btn-sm btn-danger" id="dropTable">删除</button>
+                                </div>
+                            </div>
+                            <div class="data-table-container" id="dataTableContainer">
+                                <div class="empty-state">
+                                    <span class="empty-icon">👈</span>
+                                    <p>请选择左侧的数据表</p>
+                                </div>
+                            </div>
+                            <div class="pagination" id="pagination" style="display: none;">
+                                <button class="btn btn-sm btn-outline" id="prevPage">上一页</button>
+                                <span id="pageInfo">第 1 页</span>
+                                <button class="btn btn-sm btn-outline" id="nextPage">下一页</button>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </section>
+
+            <!-- 设置页面 -->
+            <section id="page-settings" class="page">
+                <header class="page-header">
+                    <button class="sidebar-toggle" id="sidebarToggle" title="展开/收起侧边栏">
+                        <span id="sidebarToggleIcon">☰</span>
+                    </button>
+                    <div class="page-header-content">
+                        <h1>系统设置</h1>
+                    </div>
+                    <div class="page-header-actions">
+                        <button class="theme-toggle" id="themeToggle" title="切换主题">
+                            <span>🌓</span>
+                        </button>
+                        <button class="restart-btn" id="restartService" title="重启服务">
+                            <span>⏻</span>
+                        </button>
+                    </div>
+                </header>
+                <div class="page-body settings-page-body">
+                    <!-- 左侧列 -->
+                    <div class="settings-column">
+                        <!-- 数据库配置 -->
+                        <div class="card settings-card">
+                            <div class="card-header">
+                                <span class="card-title">数据库配置</span>
+                                <span class="config-update-time" id="configUpdate">-</span>
+                            </div>
+                            <div class="card-body">
+                                <div class="form-row">
+                                    <div class="form-group">
+                                        <label>主机地址</label>
+                                        <input type="text" id="configHost" class="form-input" placeholder="localhost">
+                                    </div>
+                                    <div class="form-group form-group-sm">
+                                        <label>端口</label>
+                                        <input type="number" id="configPort" class="form-input" placeholder="3306">
+                                    </div>
+                                </div>
+                                <div class="form-group">
+                                    <label>数据库名</label>
+                                    <input type="text" id="configDbname" class="form-input" placeholder="CapacityReport">
+                                </div>
+                                <div class="form-row">
+                                    <div class="form-group">
+                                        <label>用户名</label>
+                                        <input type="text" id="configUser" class="form-input" placeholder="root">
+                                    </div>
+                                    <div class="form-group">
+                                        <label>密码</label>
+                                        <div class="password-input-wrapper">
+                                            <input type="password" id="configPasswd" class="form-input" placeholder="输入密码">
+                                            <button type="button" class="password-toggle" id="togglePassword" title="显示/隐藏密码">
+                                                <span class="eye-icon">👁</span>
+                                            </button>
+                                        </div>
+                                    </div>
+                                </div>
+                            </div>
+                            <div class="card-footer">
+                                <button class="btn btn-primary" id="saveMysqlConfig">保存配置</button>
+                                <button class="btn btn-outline" id="testDbConnection">测试连接</button>
+                            </div>
+                        </div>
+                        
+                        <!-- Sheet 过滤规则 -->
+                        <div class="card settings-card">
+                            <div class="card-header">
+                                <span class="card-title">Sheet 过滤规则</span>
+                            </div>
+                            <div class="card-body">
+                                <p class="form-hint">匹配这些关键词的 Sheet 将被跳过处理</p>
+                                <div class="filter-list" id="sheetFilterList">
+                                    <!-- 动态生成 -->
+                                </div>
+                                <div class="add-filter-row">
+                                    <input type="text" id="newSheetFilter" class="form-input" placeholder="输入过滤关键词">
+                                    <button class="btn btn-outline btn-sm" id="addSheetFilter">添加</button>
+                                </div>
+                            </div>
+                            <div class="card-footer">
+                                <button class="btn btn-primary" id="saveSheetFilter">保存规则</button>
+                            </div>
+                        </div>
+                    </div>
+                    
+                    <!-- 右侧列 - 字段映射 -->
+                    <div class="settings-column settings-column-wide">
+                        <div class="card settings-card field-mapping-card">
+                            <div class="card-header">
+                                <span class="card-title">字段映射配置</span>
+                                <span class="field-count" id="fieldCount">0 个字段</span>
+                            </div>
+                            <div class="card-body">
+                                <p class="form-hint">定义 Excel 列名到数据库字段的映射规则，提取来源匹配任意一个即可</p>
+                                <div class="field-mapping-list" id="fieldMappingList">
+                                    <!-- 动态生成 -->
+                                </div>
+                            </div>
+                            <div class="card-footer">
+                                <button class="btn btn-outline" id="addFieldMapping">添加字段</button>
+                                <button class="btn btn-primary" id="saveFieldMapping">保存映射</button>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </section>
+        </main>
+    </div>
+
+    <!-- Toast 通知 -->
+    <div class="toast-container" id="toastContainer"></div>
+
+    <!-- 重启服务加载遮罩 -->
+    <div class="restart-overlay" id="restartOverlay">
+        <div class="restart-overlay-content">
+            <div class="restart-overlay-spinner"></div>
+            <div class="restart-overlay-text">正在重启服务...</div>
+        </div>
+    </div>
+
+    <!-- 确认对话框 -->
+    <div class="modal" id="confirmModal">
+        <div class="modal-backdrop"></div>
+        <div class="modal-content">
+            <h3 id="confirmTitle">确认操作</h3>
+            <p id="confirmMessage">确定要执行此操作吗？</p>
+            <div class="modal-actions">
+                <button class="btn btn-outline" id="confirmCancel">取消</button>
+                <button class="btn btn-danger" id="confirmOk">确定</button>
+            </div>
+        </div>
+    </div>
+
+    <!-- 下载选择对话框 -->
+    <div class="modal" id="downloadModal">
+        <div class="modal-backdrop"></div>
+        <div class="modal-content">
+            <h3>选择下载的数据表</h3>
+            <div class="download-options">
+                <button class="btn btn-lg btn-primary download-option" data-table="4G_结果表">
+                    <span>📊</span> 4G 结果表
+                </button>
+                <button class="btn btn-lg btn-primary download-option" data-table="5G_结果表">
+                    <span>📊</span> 5G 结果表
+                </button>
+            </div>
+            <div class="modal-actions">
+                <button class="btn btn-outline" id="downloadCancel">关闭</button>
+            </div>
+        </div>
+    </div>
+
+    <script src="/static/js/app.js"></script>
+</body>
+</html>
diff --git a/static/js/app.js b/static/js/app.js
new file mode 100644
index 0000000..14a9f85
--- /dev/null
+++ b/static/js/app.js
@@ -0,0 +1,1973 @@
+/**
+ * CapacityReport - 容量报表处理程序
+ * 前端 JavaScript - TDesign 风格
+ */
+
+// ==================== 工具函数 ====================
+
+function $(selector) {
+    return document.querySelector(selector);
+}
+
+function $$(selector) {
+    return document.querySelectorAll(selector);
+}
+
+function formatFileSize(bytes) {
+    if (bytes === 0) return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i];
+}
+
+function formatDateTime(isoString) {
+    const date = new Date(isoString);
+    return date.toLocaleString('zh-CN');
+}
+
+function getFileIcon(filename) {
+    const ext = filename.split('.').pop().toLowerCase();
+    const icons = {
+        'xlsx': '📊',
+        'xls': '📊',
+        'csv': '📋',
+        'zip': '📦'
+    };
+    return icons[ext] || '📄';
+}
+
+// Toast 通知
+function showToast(message, type = 'info') {
+    const container = $('#toastContainer');
+    const toast = document.createElement('div');
+    toast.className = `toast ${type}`;
+    
+    const icons = {
+        'success': '✓',
+        'error': '✕',
+        'warning': '!',
+        'info': 'i'
+    };
+    
+    toast.innerHTML = `
+        <span class="toast-icon">${icons[type] || 'i'}</span>
+        <span>${message}</span>
+    `;
+    container.appendChild(toast);
+    
+    setTimeout(() => {
+        toast.style.animation = 'toastIn 0.3s ease reverse';
+        setTimeout(() => toast.remove(), 300);
+    }, 3000);
+}
+
+// 确认对话框
+function showConfirm(title, message) {
+    return new Promise((resolve) => {
+        const modal = $('#confirmModal');
+        $('#confirmTitle').textContent = title;
+        $('#confirmMessage').textContent = message;
+        modal.classList.add('active');
+        
+        const handleOk = () => {
+            modal.classList.remove('active');
+            cleanup();
+            resolve(true);
+        };
+        
+        const handleCancel = () => {
+            modal.classList.remove('active');
+            cleanup();
+            resolve(false);
+        };
+        
+        const cleanup = () => {
+            $('#confirmOk').removeEventListener('click', handleOk);
+            $('#confirmCancel').removeEventListener('click', handleCancel);
+            modal.querySelector('.modal-backdrop').removeEventListener('click', handleCancel);
+        };
+        
+        $('#confirmOk').addEventListener('click', handleOk);
+        $('#confirmCancel').addEventListener('click', handleCancel);
+        modal.querySelector('.modal-backdrop').addEventListener('click', handleCancel);
+    });
+}
+
+// API 调用
+async function api(endpoint, options = {}) {
+    const response = await fetch(`/api${endpoint}`, {
+        headers: {
+            'Content-Type': 'application/json',
+            ...options.headers
+        },
+        ...options
+    });
+    
+    if (!response.ok) {
+        const error = await response.json().catch(() => ({ detail: response.statusText }));
+        throw new Error(error.detail || '请求失败');
+    }
+    
+    return response.json();
+}
+
+
+// ==================== 主题管理 ====================
+
+class ThemeManager {
+    constructor() {
+        this.theme = localStorage.getItem('theme') || 'light';
+        this.init();
+    }
+    
+    init() {
+        // 应用保存的主题
+        this.apply(this.theme);
+        
+        // 使用事件委托绑定所有主题切换按钮
+        document.addEventListener('click', (e) => {
+            if (e.target.closest('#themeToggle') || e.target.closest('#toggleThemeBtn')) {
+                this.toggle();
+            }
+        });
+        
+        // 监听系统主题变化
+        window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', (e) => {
+            if (!localStorage.getItem('theme')) {
+                this.apply(e.matches ? 'dark' : 'light');
+            }
+        });
+    }
+    
+    apply(theme) {
+        this.theme = theme;
+        document.documentElement.setAttribute('data-theme', theme);
+        
+        // 更新设置页面显示
+        const themeText = $('#currentTheme');
+        if (themeText) {
+            themeText.textContent = theme === 'dark' ? '深色模式' : '浅色模式';
+        }
+    }
+    
+    toggle() {
+        const newTheme = this.theme === 'dark' ? 'light' : 'dark';
+        this.apply(newTheme);
+        localStorage.setItem('theme', newTheme);
+        showToast(`已切换到${newTheme === 'dark' ? '深色' : '浅色'}模式`, 'success');
+    }
+}
+
+
+// ==================== 页面导航 ====================
+
+class Navigation {
+    constructor() {
+        this.currentPage = 'upload';
+        this.init();
+    }
+    
+    init() {
+        $$('.nav-item').forEach(item => {
+            item.addEventListener('click', (e) => {
+                e.preventDefault();
+                const page = item.dataset.page;
+                this.navigate(page);
+            });
+        });
+    }
+    
+    navigate(page) {
+        // 更新导航状态
+        $$('.nav-item').forEach(item => {
+            item.classList.toggle('active', item.dataset.page === page);
+        });
+        
+        // 切换页面
+        $$('.page').forEach(p => {
+            p.classList.toggle('active', p.id === `page-${page}`);
+        });
+        
+        this.currentPage = page;
+        
+        // 保存当前页面到 localStorage
+        localStorage.setItem('currentPage', page);
+        
+        // 触发页面加载事件
+        window.dispatchEvent(new CustomEvent('pagechange', { detail: { page } }));
+        
+        // 如果导航到上传页面，检查活动任务
+        if (page === 'upload') {
+            const uploader = window.fileUploader;
+            if (uploader && uploader.checkActiveTask) {
+                uploader.checkActiveTask();
+            }
+        }
+    }
+    
+    restorePage() {
+        // 从 localStorage 恢复页面
+        const savedPage = localStorage.getItem('currentPage');
+        console.log('恢复页面:', savedPage);
+        if (savedPage) {
+            // 验证页面是否存在
+            const pageEl = $(`#page-${savedPage}`);
+            if (pageEl) {
+                this.navigate(savedPage);
+                return;
+            }
+        }
+        // 如果没有保存的页面或页面不存在，确保默认显示上传页面
+        // HTML 中已经设置了 upload 为默认 active，这里不需要额外操作
+    }
+}
+
+
+// ==================== 文件上传 ====================
+
+class FileUploader {
+    constructor() {
+        this.files = [];
+        this.taskId = null;
+        this.pollInterval = null;
+        this.isUploading = false;
+        this.uploadStats = {
+            total: 0,
+            uploading: 0,
+            success: 0,
+            error: 0
+        };
+        this.init();
+    }
+    
+    init() {
+        const uploadZone = $('#uploadZone');
+        const fileInput = $('#fileInput');
+        const fileInputSingle = $('#fileInputSingle');
+        
+        // 拖拽事件
+        uploadZone.addEventListener('dragover', (e) => {
+            e.preventDefault();
+            uploadZone.classList.add('dragover');
+        });
+        
+        uploadZone.addEventListener('dragleave', () => {
+            uploadZone.classList.remove('dragover');
+        });
+        
+        uploadZone.addEventListener('drop', async (e) => {
+            e.preventDefault();
+            uploadZone.classList.remove('dragover');
+            
+            const items = e.dataTransfer.items;
+            const files = [];
+            
+            for (let item of items) {
+                if (item.kind === 'file') {
+                    const entry = item.webkitGetAsEntry();
+                    if (entry) {
+                        await this.traverseEntry(entry, files, '');
+                    }
+                }
+            }
+            
+            this.addFiles(files);
+        });
+        
+        // 文件选择（目录）
+        fileInput.addEventListener('change', (e) => {
+            const files = Array.from(e.target.files).map(f => ({
+                file: f,
+                path: f.webkitRelativePath || f.name
+            }));
+            this.addFiles(files);
+            fileInput.value = '';
+        });
+        
+        // 点击上传区域时选择文件
+        uploadZone.addEventListener('click', (e) => {
+            if (e.target === uploadZone || e.target.closest('.upload-icon') || e.target.closest('h3') || e.target.closest('p')) {
+                fileInputSingle.click();
+            }
+        });
+        
+        fileInputSingle.addEventListener('change', (e) => {
+            const files = Array.from(e.target.files).map(f => ({
+                file: f,
+                path: f.name
+            }));
+            this.addFiles(files);
+            fileInputSingle.value = '';
+        });
+        
+        // 清空按钮
+        $('#clearFiles').addEventListener('click', () => {
+            if (!this.isUploading) {
+                this.clearFiles();
+            }
+        });
+        
+        // 上传按钮
+        $('#startUpload').addEventListener('click', () => {
+            this.upload();
+        });
+        
+        // 不在页面加载时自动检查任务，只在用户导航到上传页面时检查
+        // 避免无意义的轮询请求
+        
+        // 下载结果按钮
+        $('#downloadResult').addEventListener('click', () => {
+            $('#downloadModal').classList.add('active');
+        });
+        
+        // 下载选项
+        $$('.download-option').forEach(btn => {
+            btn.addEventListener('click', async () => {
+                const table = btn.dataset.table;
+                try {
+                    const response = await fetch('/api/download', {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        },
+                        body: JSON.stringify({
+                            table_name: table,
+                            format: 'xlsx'
+                        })
+                    });
+                    
+                    if (!response.ok) {
+                        throw new Error('下载失败');
+                    }
+                    
+                    const blob = await response.blob();
+                    const url = window.URL.createObjectURL(blob);
+                    const a = document.createElement('a');
+                    a.href = url;
+                    a.download = `${table}_${new Date().toISOString().slice(0, 10)}.xlsx`;
+                    document.body.appendChild(a);
+                    a.click();
+                    document.body.removeChild(a);
+                    window.URL.revokeObjectURL(url);
+                } catch (error) {
+                    showToast(`下载失败: ${error.message}`, 'error');
+                }
+                $('#downloadModal').classList.remove('active');
+            });
+        });
+        
+        $('#downloadCancel').addEventListener('click', () => {
+            $('#downloadModal').classList.remove('active');
+        });
+        
+        // 关闭模态框点击背景
+        $('#downloadModal .modal-backdrop').addEventListener('click', () => {
+            $('#downloadModal').classList.remove('active');
+        });
+        
+        // 新建任务
+        $('#newProcess').addEventListener('click', () => {
+            this.reset();
+        });
+    }
+    
+    async traverseEntry(entry, files, path) {
+        if (entry.isFile) {
+            return new Promise((resolve) => {
+                entry.file((file) => {
+                    const fullPath = path ? `${path}/${file.name}` : file.name;
+                    files.push({ file, path: fullPath });
+                    resolve();
+                });
+            });
+        } else if (entry.isDirectory) {
+            const reader = entry.createReader();
+            return new Promise((resolve) => {
+                reader.readEntries(async (entries) => {
+                    const newPath = path ? `${path}/${entry.name}` : entry.name;
+                    for (let subEntry of entries) {
+                        await this.traverseEntry(subEntry, files, newPath);
+                    }
+                    resolve();
+                });
+            });
+        }
+    }
+    
+    addFiles(newFiles) {
+        if (this.isUploading) return;
+        
+        // 过滤有效文件
+        const validExtensions = ['.zip', '.xlsx', '.xls', '.csv'];
+        const filtered = newFiles.filter(f => {
+            const ext = '.' + f.path.split('.').pop().toLowerCase();
+            return validExtensions.includes(ext);
+        }).map(f => ({
+            ...f,
+            status: 'pending', // pending, uploading, uploaded, error
+            progress: 0
+        }));
+        
+        this.files.push(...filtered);
+        this.updateFileList();
+    }
+    
+    updateFileList() {
+        const fileList = $('#fileList');
+        const fileItems = $('#fileItems');
+        const fileCount = $('#fileCount');
+        
+        if (this.files.length === 0) {
+            fileList.style.display = 'none';
+            return;
+        }
+        
+        fileList.style.display = 'block';
+        fileItems.innerHTML = this.files.map((f, i) => `
+            <div class="file-item ${f.status}" data-index="${i}" id="file-item-${i}">
+                <span class="file-item-icon">${getFileIcon(f.path)}</span>
+                <span class="file-item-name" title="${f.path}">${f.path}</span>
+                <span class="file-item-size">${formatFileSize(f.file.size)}</span>
+                <span class="file-item-status ${f.status}">
+                    ${this.getStatusText(f.status, f.progress)}
+                </span>
+                ${f.status !== 'pending' ? `
+                    <div class="file-progress">
+                        <div class="file-progress-bar" style="width: ${f.progress}%"></div>
+                    </div>
+                ` : ''}
+            </div>
+        `).join('');
+        
+        fileCount.textContent = `${this.files.length} 个文件`;
+    }
+    
+    getStatusText(status, progress) {
+        switch (status) {
+            case 'pending': return '等待上传';
+            case 'uploading': return `上传中 ${progress}%`;
+            case 'uploaded': return '✓ 已完成';
+            case 'error': return '✕ 失败';
+            default: return '';
+        }
+    }
+    
+    updateFileStatus(index, status, progress = 0) {
+        if (this.files[index]) {
+            this.files[index].status = status;
+            this.files[index].progress = progress;
+            
+            const fileItem = $(`#file-item-${index}`);
+            if (fileItem) {
+                // 更新样式类
+                fileItem.className = `file-item ${status}`;
+                fileItem.dataset.index = index;
+                fileItem.id = `file-item-${index}`;
+                
+                // 更新状态文本
+                const statusEl = fileItem.querySelector('.file-item-status');
+                if (statusEl) {
+                    statusEl.className = `file-item-status ${status}`;
+                    statusEl.textContent = this.getStatusText(status, progress);
+                }
+                
+                // 更新或创建进度条
+                let progressEl = fileItem.querySelector('.file-progress');
+                if (status !== 'pending') {
+                    if (!progressEl) {
+                        progressEl = document.createElement('div');
+                        progressEl.className = 'file-progress';
+                        progressEl.innerHTML = '<div class="file-progress-bar"></div>';
+                        fileItem.appendChild(progressEl);
+                    }
+                    progressEl.querySelector('.file-progress-bar').style.width = `${progress}%`;
+                }
+                
+                // 自动滚动到当前上传的文件
+                if (status === 'uploading') {
+                    fileItem.scrollIntoView({ behavior: 'smooth', block: 'center' });
+                }
+            }
+        }
+    }
+    
+    updateUploadStats() {
+        const stats = {
+            total: this.files.length,
+            uploading: this.files.filter(f => f.status === 'uploading').length,
+            success: this.files.filter(f => f.status === 'uploaded').length,
+            error: this.files.filter(f => f.status === 'error').length
+        };
+        
+        $('#statsTotal').textContent = stats.total;
+        $('#statsUploading').textContent = stats.uploading;
+        $('#statsSuccess').textContent = stats.success;
+        $('#statsError').textContent = stats.error;
+        
+        // 更新总进度
+        const totalProgress = Math.round((stats.success + stats.error) / stats.total * 100);
+        $('#totalPercent').textContent = `${totalProgress}%`;
+        $('#totalProgressBar').style.width = `${totalProgress}%`;
+    }
+    
+    clearFiles() {
+        this.files = [];
+        this.updateFileList();
+        $('#totalProgress').style.display = 'none';
+        $('#uploadStats').style.display = 'none';
+    }
+    
+    async upload() {
+        if (this.files.length === 0) {
+            showToast('请先选择文件', 'warning');
+            return;
+        }
+        
+        if (this.isUploading) {
+            showToast('正在上传中，请稍候', 'warning');
+            return;
+        }
+        
+        // 检查是否有其他任务在运行
+        try {
+            const statusCheck = await api('/task/status', { method: 'POST' });
+            if (statusCheck.has_active) {
+                const stageText = statusCheck.stage === 'uploading' ? '上传' : '处理';
+                showToast(`已有任务在运行（${stageText}中）`, 'warning');
+                // 显示当前任务状态
+                this.taskId = statusCheck.task_id;
+                $('#uploadZone').style.display = 'none';
+                $('#fileList').style.display = 'none';
+                $('#processSection').style.display = 'block';
+                $('#processActions').style.display = 'none';
+                $('#processStatus').className = 'process-status processing';
+                $('#processStatus').textContent = statusCheck.stage === 'uploading' ? '上传中...' : '处理中...';
+                if (statusCheck.logs && statusCheck.logs.length > 0) {
+                    const logContent = $('#logContent');
+                    logContent.innerHTML = statusCheck.logs.map(log => {
+                        let level = 'info';
+                        if (log.includes('[SUCCESS]')) level = 'success';
+                        else if (log.includes('[ERROR]')) level = 'error';
+                        else if (log.includes('[WARN]')) level = 'warn';
+                        return `<div class="log-line ${level}">${log}</div>`;
+                    }).join('');
+                }
+                if (statusCheck.stage === 'processing') {
+                    this.pollStatus();
+                } else {
+                    this.pollGlobalStatus();
+                }
+                return;
+            }
+        } catch (error) {
+            console.error('检查任务状态失败:', error);
+        }
+        
+        // 立即更新UI状态（在开始上传前）
+        // 隐藏上传区域和文件列表
+        $('#uploadZone').style.display = 'none';
+        $('#fileList').style.display = 'none';
+        $('#totalProgress').style.display = 'none';
+        $('#uploadStats').style.display = 'none';
+        
+        // 显示处理区域（上传中状态）
+        $('#processSection').style.display = 'block';
+        $('#processActions').style.display = 'none';
+        $('#logContent').innerHTML = '<div class="log-line info">正在上传文件...</div>';
+        $('#processStatus').className = 'process-status processing';
+        $('#processStatus').textContent = '上传中...';
+        
+        // 强制浏览器重绘
+        $('#processSection').offsetHeight;
+        
+        this.isUploading = true;
+        $('#startUpload').disabled = true;
+        $('#clearFiles').disabled = true;
+        
+        showToast('开始批量上传文件...', 'info');
+        
+        try {
+            // 创建 FormData，添加所有文件
+            const formData = new FormData();
+            this.files.forEach(fileData => {
+                formData.append('files', fileData.file, fileData.path);
+            });
+            
+            // 使用 XMLHttpRequest 来跟踪上传进度
+            const result = await new Promise((resolve, reject) => {
+                const xhr = new XMLHttpRequest();
+                
+                // 上传进度事件
+                xhr.upload.addEventListener('progress', (e) => {
+                    if (e.lengthComputable) {
+                        const progress = Math.round((e.loaded / e.total) * 100);
+                        // 更新日志显示进度
+                        $('#logContent').innerHTML = `<div class="log-line info">正在上传文件... ${progress}%</div>`;
+                        $('#processStatus').textContent = `上传中 ${progress}%`;
+                    }
+                });
+                
+                // 完成事件
+                xhr.addEventListener('load', () => {
+                    if (xhr.status >= 200 && xhr.status < 300) {
+                        try {
+                            const result = JSON.parse(xhr.responseText);
+                            resolve(result);
+                        } catch {
+                            resolve({ success: true });
+                        }
+                    } else {
+                        reject(new Error('上传失败'));
+                    }
+                });
+                
+                // 错误事件
+                xhr.addEventListener('error', () => {
+                    reject(new Error('网络错误'));
+                });
+                
+                // 开始上传
+                xhr.open('POST', '/api/upload');
+                xhr.send(formData);
+            });
+            
+            // 上传成功，获取后端返回的任务ID
+            const taskId = result.task_id || result.session_id;
+            if (!taskId) {
+                throw new Error('未获取到任务ID');
+            }
+            
+            this.taskId = taskId;
+            console.log('上传完成，任务ID:', taskId);
+            
+            // 注意：锁定已在后端上传接口中完成，这里不需要再次锁定
+            
+            // 更新UI显示上传完成
+            $('#logContent').innerHTML = `<div class="log-line success">上传完成: ${result.file_count || this.files.length} 个文件</div>`;
+            $('#processStatus').textContent = '准备开始处理...';
+            showToast(`上传完成: ${result.file_count || this.files.length} 个文件`, 'success');
+            
+            // 立即开始处理（不等待）
+            console.log('开始启动处理任务...');
+            this.startProcessing().catch(error => {
+                console.error('启动处理失败:', error);
+                showToast(`启动处理失败: ${error.message}`, 'error');
+                // 如果启动失败，恢复显示上传区域
+                $('#processSection').style.display = 'none';
+                this.restoreUploadUI();
+            });
+            
+        } catch (error) {
+            showToast(`上传失败: ${error.message}`, 'error');
+            console.error('上传失败:', error);
+            // 上传失败，解锁全局任务（后端会自动处理，但这里也尝试解锁）
+            if (this.taskId) {
+                try {
+                    await api('/task/unlock', {
+                        method: 'POST',
+                        body: JSON.stringify({ task_id: this.taskId })
+                    });
+                } catch (unlockError) {
+                    console.error('解锁任务失败:', unlockError);
+                }
+            }
+            // 恢复显示上传区域
+            $('#processSection').style.display = 'none';
+            this.restoreUploadUI();
+        } finally {
+            this.isUploading = false;
+            $('#startUpload').disabled = false;
+            $('#clearFiles').disabled = false;
+        }
+    }
+    
+    async startProcessing() {
+        if (!this.taskId) {
+            console.error('startProcessing: taskId 为空');
+            return;
+        }
+        
+        console.log('startProcessing: 开始启动处理，taskId =', this.taskId);
+        
+        try {
+            // 更新UI状态
+            $('#processStatus').textContent = '正在启动处理...';
+            $('#logContent').innerHTML = '<div class="log-line info">正在启动数据处理任务...</div>';
+            
+            const response = await api('/process/start', { 
+                method: 'POST',
+                body: JSON.stringify({ task_id: this.taskId })
+            });
+            
+            console.log('startProcessing: 处理任务已启动，响应:', response);
+            
+            // 显示处理区域
+            $('#processSection').style.display = 'block';
+            $('#processActions').style.display = 'none';
+            $('#processStatus').className = 'process-status processing';
+            $('#processStatus').textContent = '处理中...';
+            $('#logContent').innerHTML = '<div class="log-line info">处理任务已启动，等待日志...</div>';
+            
+            // 确保上传区域和文件列表保持隐藏
+            $('#uploadZone').style.display = 'none';
+            $('#fileList').style.display = 'none';
+            
+            // 开始轮询状态（延迟一点，确保后端已经开始处理）
+            setTimeout(() => {
+                this.pollStatus();
+            }, 500);
+            
+        } catch (error) {
+            console.error('startProcessing: 启动处理失败:', error);
+            showToast(`启动处理失败: ${error.message}`, 'error');
+            // 如果启动失败，恢复显示上传区域
+            $('#processSection').style.display = 'none';
+            this.restoreUploadUI();
+            // 解锁全局任务
+            if (this.taskId) {
+                try {
+                    await api('/task/unlock', {
+                        method: 'POST',
+                        body: JSON.stringify({ task_id: this.taskId })
+                    });
+                } catch (unlockError) {
+                    console.error('解锁任务失败:', unlockError);
+                }
+            }
+        }
+    }
+    
+    pollStatus() {
+        if (this.pollInterval) {
+            clearInterval(this.pollInterval);
+        }
+        
+        if (!this.taskId) {
+            console.error('轮询状态失败: taskId 为空');
+            this.restoreUploadUI();
+            return;
+        }
+        
+        console.log('开始轮询任务状态:', this.taskId);
+        
+        // 绑定手动刷新按钮
+        const manualRefreshBtn = $('#manualRefreshLog');
+        if (manualRefreshBtn) {
+            manualRefreshBtn.onclick = () => {
+                this.refreshLogOnce();
+            };
+        }
+        
+        // 监听自动刷新开关变化
+        const autoRefreshCheckbox = $('#autoRefreshLog');
+        if (autoRefreshCheckbox) {
+            autoRefreshCheckbox.addEventListener('change', (e) => {
+                if (e.target.checked) {
+                    // 开启自动刷新，重新开始轮询
+                    if (!this.pollInterval) {
+                        this.pollStatus();
+                    }
+                } else {
+                    // 关闭自动刷新，停止轮询
+                    if (this.pollInterval) {
+                        clearInterval(this.pollInterval);
+                        this.pollInterval = null;
+                        console.log('已停止自动刷新轮询');
+                    }
+                }
+            });
+        }
+        
+        const poll = async () => {
+            try {
+                // 检查自动刷新开关
+                const autoRefreshCheckbox = $('#autoRefreshLog');
+                if (autoRefreshCheckbox && !autoRefreshCheckbox.checked) {
+                    // 如果关闭了自动刷新，停止轮询
+                    if (this.pollInterval) {
+                        clearInterval(this.pollInterval);
+                        this.pollInterval = null;
+                    }
+                    return;
+                }
+                const status = await api('/process/status', { 
+                    method: 'POST',
+                    body: JSON.stringify({ task_id: this.taskId })
+                });
+                
+                // 更新日志
+                const logContent = $('#logContent');
+                if (status.logs && status.logs.length > 0) {
+                    logContent.innerHTML = status.logs.map(log => {
+                        let level = 'info';
+                        if (log.includes('[SUCCESS]')) level = 'success';
+                        else if (log.includes('[ERROR]')) level = 'error';
+                        else if (log.includes('[WARN]')) level = 'warn';
+                        return `<div class="log-line ${level}">${log}</div>`;
+                    }).join('');
+                }
+                
+                // 自动滚动到底部（仅在自动刷新开启时）
+                if (autoRefreshCheckbox && autoRefreshCheckbox.checked) {
+                    const container = $('#logContainer');
+                    container.scrollTop = container.scrollHeight;
+                }
+                
+                // 更新状态
+                const statusEl = $('#processStatus');
+                if (status.status === 'completed') {
+                    statusEl.textContent = '处理完成';
+                    statusEl.className = 'process-status completed';
+                    $('#processActions').style.display = 'flex';
+                    // 任务完成，立即停止轮询
+                    if (this.pollInterval) {
+                        clearInterval(this.pollInterval);
+                        this.pollInterval = null;
+                    }
+                    showToast('数据处理完成！', 'success');
+                    // 任务完成，不立即恢复上传区域，让用户查看结果
+                    // 用户可以通过点击"新任务"按钮或切换页面来重置
+                    this.files = [];  // 清空已上传的文件
+                } else if (status.status === 'failed') {
+                    statusEl.textContent = '处理失败';
+                    statusEl.className = 'process-status failed';
+                    $('#processActions').style.display = 'flex';
+                    // 任务失败，立即停止轮询
+                    if (this.pollInterval) {
+                        clearInterval(this.pollInterval);
+                        this.pollInterval = null;
+                    }
+                    showToast('数据处理失败', 'error');
+                    // 任务失败，不立即恢复上传区域
+                    this.files = [];
+                } else {
+                    statusEl.textContent = '处理中...';
+                    statusEl.className = 'process-status processing';
+                }
+                
+            } catch (error) {
+                console.error('轮询状态失败:', error);
+                // 如果请求失败（如 404），可能是任务ID错误
+                if (error.message && error.message.includes('404')) {
+                    clearInterval(this.pollInterval);
+                    showToast('任务状态获取失败', 'error');
+                    $('#processStatus').textContent = '状态获取失败';
+                    $('#processStatus').className = 'process-status failed';
+                    this.restoreUploadUI();
+                }
+            }
+        };
+        
+        poll();
+        this.pollInterval = setInterval(poll, 1000);
+    }
+    
+    async refreshLogOnce() {
+        if (!this.taskId) return;
+        
+        try {
+            const status = await api('/process/status', { 
+                method: 'POST',
+                body: JSON.stringify({ task_id: this.taskId })
+            });
+            
+            // 更新日志
+            const logContent = $('#logContent');
+            if (status.logs && status.logs.length > 0) {
+                logContent.innerHTML = status.logs.map(log => {
+                    let level = 'info';
+                    if (log.includes('[SUCCESS]')) level = 'success';
+                    else if (log.includes('[ERROR]')) level = 'error';
+                    else if (log.includes('[WARN]')) level = 'warn';
+                    return `<div class="log-line ${level}">${log}</div>`;
+                }).join('');
+            }
+            
+            // 不自动滚动，让用户自己控制
+        } catch (error) {
+            console.error('手动刷新日志失败:', error);
+        }
+    }
+    
+    restoreUploadUI() {
+        // 恢复显示上传区域（使用 flex 布局）
+        $('#uploadZone').style.display = 'flex';
+        // 只有当有文件时才显示文件列表
+        if (this.files.length > 0) {
+            $('#fileList').style.display = 'block';
+        }
+        // 隐藏进度和统计
+        $('#totalProgress').style.display = 'none';
+        $('#uploadStats').style.display = 'none';
+        this.isUploading = false;
+        $('#startUpload').disabled = false;
+        $('#clearFiles').disabled = false;
+    }
+    
+    reset() {
+        this.files = [];
+        this.taskId = null;
+        this.isUploading = false;
+        if (this.pollInterval) {
+            clearInterval(this.pollInterval);
+            this.pollInterval = null;
+        }
+        
+        this.updateFileList();
+        // 隐藏处理区域
+        $('#processSection').style.display = 'none';
+        $('#processActions').style.display = 'none';
+        $('#processStatus').className = 'process-status processing';
+        $('#processStatus').textContent = '处理中...';
+        $('#logContent').innerHTML = '';
+        // 恢复显示上传区域
+        this.restoreUploadUI();
+        console.log('任务已重置，UI 已恢复');
+    }
+    
+    async checkActiveTask() {
+        // 检查是否有正在进行的任务（全局状态）
+        // 只在用户导航到上传页面时调用，避免无意义的请求
+        try {
+            const result = await api('/task/status', { method: 'POST' });
+            if (result.has_active) {
+                // 有任务正在进行，隐藏上传区域，显示处理进度
+                $('#uploadZone').style.display = 'none';
+                $('#fileList').style.display = 'none';
+                $('#totalProgress').style.display = 'none';
+                $('#uploadStats').style.display = 'none';
+                this.taskId = result.task_id;
+                $('#processSection').style.display = 'block';
+                $('#processActions').style.display = 'none';
+                $('#processStatus').className = 'process-status processing';
+                
+                // 根据阶段显示不同状态
+                const stageText = result.stage === 'uploading' ? '上传中...' : '处理中...';
+                $('#processStatus').textContent = stageText;
+                
+                // 显示已有的日志
+                if (result.logs && result.logs.length > 0) {
+                    const logContent = $('#logContent');
+                    logContent.innerHTML = result.logs.map(log => {
+                        let level = 'info';
+                        if (log.includes('[SUCCESS]')) level = 'success';
+                        else if (log.includes('[ERROR]')) level = 'error';
+                        else if (log.includes('[WARN]')) level = 'warn';
+                        return `<div class="log-line ${level}">${log}</div>`;
+                    }).join('');
+                    const container = $('#logContainer');
+                    container.scrollTop = container.scrollHeight;
+                } else if (result.stage === 'uploading') {
+                    $('#logContent').innerHTML = '<div class="log-line info">正在上传文件...</div>';
+                } else {
+                    $('#logContent').innerHTML = '';
+                }
+                
+                // 只有在处理中且自动刷新开启时才开始轮询
+                // 避免多人同时轮询导致并发过大
+                if (result.stage === 'processing') {
+                    const autoRefreshCheckbox = $('#autoRefreshLog');
+                    if (autoRefreshCheckbox && autoRefreshCheckbox.checked) {
+                        this.pollStatus();
+                    }
+                } else if (result.stage === 'uploading') {
+                    // 上传中，轮询全局状态（但也要检查自动刷新）
+                    const autoRefreshCheckbox = $('#autoRefreshLog');
+                    if (autoRefreshCheckbox && autoRefreshCheckbox.checked) {
+                        this.pollGlobalStatus();
+                    }
+                }
+            }
+        } catch (error) {
+            console.error('检查活动任务失败:', error);
+        }
+    }
+    
+    pollGlobalStatus() {
+        // 轮询全局任务状态（用于等待上传完成）
+        if (this.pollInterval) {
+            clearInterval(this.pollInterval);
+        }
+        
+        const poll = async () => {
+            try {
+                // 检查自动刷新开关，如果关闭则停止轮询
+                const autoRefreshCheckbox = $('#autoRefreshLog');
+                if (autoRefreshCheckbox && !autoRefreshCheckbox.checked) {
+                    if (this.pollInterval) {
+                        clearInterval(this.pollInterval);
+                        this.pollInterval = null;
+                    }
+                    return;
+                }
+                
+                const result = await api('/task/status', { method: 'POST' });
+                
+                if (!result.has_active) {
+                    // 任务已完成或取消，停止轮询并恢复上传界面
+                    if (this.pollInterval) {
+                        clearInterval(this.pollInterval);
+                        this.pollInterval = null;
+                    }
+                    $('#processSection').style.display = 'none';
+                    this.restoreUploadUI();
+                    showToast('任务已完成', 'info');
+                } else if (result.stage === 'processing') {
+                    // 转为处理中状态，切换到处理轮询
+                    if (this.pollInterval) {
+                        clearInterval(this.pollInterval);
+                        this.pollInterval = null;
+                    }
+                    this.taskId = result.task_id;
+                    $('#processStatus').textContent = '处理中...';
+                    // 只有自动刷新开启时才继续轮询
+                    if (autoRefreshCheckbox && autoRefreshCheckbox.checked) {
+                        this.pollStatus();
+                    }
+                } else {
+                    // 仍在上传中
+                    $('#processStatus').textContent = '上传中...';
+                }
+            } catch (error) {
+                console.error('轮询全局状态失败:', error);
+            }
+        };
+        
+        poll();
+        this.pollInterval = setInterval(poll, 1000);
+    }
+}
+
+
+// ==================== 历史记录 ====================
+
+class HistoryManager {
+    constructor() {
+        this.init();
+    }
+    
+    init() {
+        $('#refreshHistory').addEventListener('click', () => this.load());
+        $('#clearHistory').addEventListener('click', () => this.clear());
+        
+        window.addEventListener('pagechange', (e) => {
+            if (e.detail.page === 'history') {
+                this.load();
+            }
+        });
+    }
+    
+    async load() {
+        const container = $('#historyList');
+        container.innerHTML = '<div class="loading">加载中...</div>';
+        
+        try {
+            const data = await api('/history', { method: 'POST' });
+            
+            if (data.records.length === 0) {
+                container.innerHTML = `
+                    <div class="empty-state">
+                        <span class="empty-icon">📭</span>
+                        <p>暂无处理记录</p>
+                    </div>
+                `;
+                return;
+            }
+            
+            container.innerHTML = data.records.map(record => `
+                <div class="history-item" data-id="${record.id}">
+                    <div class="history-status ${record.status}"></div>
+                    <div class="history-info">
+                        <div class="history-id">${record.id}</div>
+                        <div class="history-meta">
+                            ${formatDateTime(record.timestamp)} · 
+                            ${record.file_count} 个文件 · 
+                            ${record.elapsed_time ? record.elapsed_time + ' 秒' : '-'} · 
+                            <span class="record-size" data-id="${record.id}">计算中...</span>
+                        </div>
+                    </div>
+                    <div class="history-actions">
+                        <button class="btn btn-sm btn-outline view-log" data-id="${record.id}">
+                            📋 日志
+                        </button>
+                        <button class="btn btn-sm btn-danger delete-record" data-id="${record.id}">
+                            🗑️
+                        </button>
+                    </div>
+                </div>
+            `).join('');
+            
+            // 加载每个记录的占用大小
+            container.querySelectorAll('.record-size').forEach(el => {
+                this.loadRecordSize(el.dataset.id, el);
+            });
+            
+            // 加载总占用大小
+            this.loadTotalSize();
+            
+            // 绑定事件
+            container.querySelectorAll('.view-log').forEach(btn => {
+                btn.addEventListener('click', (e) => {
+                    e.stopPropagation();
+                    this.viewLog(btn.dataset.id);
+                });
+            });
+            
+            container.querySelectorAll('.delete-record').forEach(btn => {
+                btn.addEventListener('click', (e) => {
+                    e.stopPropagation();
+                    this.delete(btn.dataset.id);
+                });
+            });
+            
+        } catch (error) {
+            container.innerHTML = `<div class="empty-state"><p>加载失败: ${error.message}</p></div>`;
+        }
+    }
+    
+    async viewLog(id) {
+        try {
+            const record = await api('/history/detail', { 
+                method: 'POST',
+                body: JSON.stringify({ record_id: id })
+            });
+            
+            // 使用模态框显示日志
+            const modal = document.createElement('div');
+            modal.className = 'modal active';
+            modal.innerHTML = `
+                <div class="modal-backdrop"></div>
+                <div class="modal-content" style="width: 800px; max-height: 80vh;">
+                    <h3>处理日志 - ${id}</h3>
+                    <div class="log-container" style="height: 400px; margin-bottom: 16px;">
+                        <div class="log-content">
+                            ${record.logs.map(log => {
+                                let level = 'info';
+                                if (log.includes('[SUCCESS]')) level = 'success';
+                                else if (log.includes('[ERROR]')) level = 'error';
+                                else if (log.includes('[WARN]')) level = 'warn';
+                                return `<div class="log-line ${level}">${log}</div>`;
+                            }).join('')}
+                        </div>
+                    </div>
+                    <div class="modal-actions">
+                        <button class="btn btn-outline close-modal">关闭</button>
+                    </div>
+                </div>
+            `;
+            
+            document.body.appendChild(modal);
+            
+            modal.querySelector('.close-modal').addEventListener('click', () => modal.remove());
+            modal.querySelector('.modal-backdrop').addEventListener('click', () => modal.remove());
+            
+        } catch (error) {
+            showToast(`加载日志失败: ${error.message}`, 'error');
+        }
+    }
+    
+    async delete(id) {
+        const confirmed = await showConfirm('删除记录', '确定要删除这条历史记录吗？');
+        if (!confirmed) return;
+        
+        try {
+            await api('/history/delete', { method: 'POST', body: JSON.stringify({ record_id: id }) });
+            showToast('删除成功', 'success');
+            this.load();
+        } catch (error) {
+            showToast(`删除失败: ${error.message}`, 'error');
+        }
+    }
+    
+    async clear() {
+        const confirmed = await showConfirm('清空历史', '确定要清空所有历史记录吗？此操作不可恢复。');
+        if (!confirmed) return;
+        
+        try {
+            await api('/history/clear', { method: 'POST' });
+            showToast('已清空所有历史记录', 'success');
+            this.load();
+        } catch (error) {
+            showToast(`清空失败: ${error.message}`, 'error');
+        }
+    }
+    
+    async loadRecordSize(recordId, element) {
+        try {
+            const result = await api('/history/size', {
+                method: 'POST',
+                body: JSON.stringify({ record_id: recordId })
+            });
+            if (result.success) {
+                element.textContent = result.size_formatted;
+            } else {
+                element.textContent = '计算失败';
+            }
+        } catch (error) {
+            element.textContent = '计算失败';
+        }
+    }
+    
+    async loadTotalSize() {
+        const totalSizeEl = $('#totalHistorySize');
+        if (!totalSizeEl) return;
+        
+        try {
+            const result = await api('/cache/size', { method: 'POST' });
+            if (result.success) {
+                totalSizeEl.textContent = result.size_formatted;
+            } else {
+                totalSizeEl.textContent = '计算失败';
+            }
+        } catch (error) {
+            totalSizeEl.textContent = '计算失败';
+        }
+    }
+}
+
+
+// ==================== 数据库管理 ====================
+
+class DatabaseManager {
+    constructor() {
+        this.currentTable = null;
+        this.currentPage = 1;
+        this.pageSize = 50;
+        this.totalPages = 1;
+        this.columns = [];
+        this.init();
+    }
+    
+    init() {
+        $('#searchInput').addEventListener('keyup', (e) => {
+            if (e.key === 'Enter') {
+                this.search();
+            }
+        });
+        
+        $('#downloadTable').addEventListener('click', () => this.downloadTable());
+        $('#truncateTable').addEventListener('click', () => this.truncateTable());
+        $('#dropTable').addEventListener('click', () => this.dropTable());
+        
+        $('#prevPage').addEventListener('click', () => {
+            if (this.currentPage > 1) {
+                this.currentPage--;
+                this.loadData();
+            }
+        });
+        
+        $('#nextPage').addEventListener('click', () => {
+            if (this.currentPage < this.totalPages) {
+                this.currentPage++;
+                this.loadData();
+            }
+        });
+        
+        window.addEventListener('pagechange', (e) => {
+            if (e.detail.page === 'database') {
+                this.testConnection();
+                this.loadTables();
+            }
+        });
+    }
+    
+    async testConnection() {
+        const connEl = $('#dbConnection');
+        connEl.innerHTML = '<span class="status-dot"></span><span>检测连接中...</span>';
+        
+        try {
+            const result = await api('/database/test');
+            const dot = connEl.querySelector('.status-dot');
+            
+            if (result.success) {
+                dot.classList.add('connected');
+                connEl.querySelector('span:last-child').textContent = '已连接';
+            } else {
+                dot.classList.add('error');
+                connEl.querySelector('span:last-child').textContent = '连接失败';
+            }
+        } catch (error) {
+            const dot = connEl.querySelector('.status-dot');
+            dot.classList.add('error');
+            connEl.querySelector('span:last-child').textContent = '连接失败';
+        }
+    }
+    
+    async loadTables() {
+        const container = $('#tableList');
+        container.innerHTML = '<div class="loading">加载中...</div>';
+        
+        try {
+            const data = await api('/database/tables');
+            
+            if (data.tables.length === 0) {
+                container.innerHTML = '<div class="empty-state" style="padding: 24px;"><p>暂无数据表</p></div>';
+                return;
+            }
+            
+            container.innerHTML = data.tables.map(table => `
+                <div class="table-item" data-table="${table}">
+                    <span class="table-icon">📊</span>
+                    <span>${table}</span>
+                </div>
+            `).join('');
+            
+            container.querySelectorAll('.table-item').forEach(item => {
+                item.addEventListener('click', () => {
+                    container.querySelectorAll('.table-item').forEach(i => i.classList.remove('active'));
+                    item.classList.add('active');
+                    this.selectTable(item.dataset.table);
+                });
+            });
+            
+        } catch (error) {
+            container.innerHTML = `<div class="empty-state" style="padding: 24px;"><p>加载失败</p></div>`;
+        }
+    }
+    
+    async selectTable(tableName) {
+        this.currentTable = tableName;
+        this.currentPage = 1;
+        
+        $('#dbToolbar').style.display = 'flex';
+        $('#currentTable').textContent = tableName;
+        $('#pagination').style.display = 'flex';
+        
+        try {
+            const info = await api('/database/table/info', {
+                method: 'POST',
+                body: JSON.stringify({ table_name: tableName })
+            });
+            this.columns = info.columns.map(c => c.Field);
+            $('#rowCount').textContent = `${info.row_count} 行`;
+            
+            await this.loadData();
+            
+        } catch (error) {
+            showToast(`加载表信息失败: ${error.message}`, 'error');
+        }
+    }
+    
+    async loadData() {
+        const container = $('#dataTableContainer');
+        container.innerHTML = '<div class="loading">加载中...</div>';
+        
+        try {
+            const searchValue = $('#searchInput').value.trim();
+            let result;
+            
+            if (searchValue && this.columns.length > 0) {
+                // 构建筛选条件（只用第一个字段搜索以提高性能）
+                const filters = {};
+                if (this.columns[0]) {
+                    filters[this.columns[0]] = searchValue;
+                }
+                
+                result = await api('/database/table/query', {
+                    method: 'POST',
+                    body: JSON.stringify({
+                        table_name: this.currentTable,
+                        page: this.currentPage,
+                        page_size: this.pageSize,
+                        filters: filters
+                    })
+                });
+            } else {
+                result = await api('/database/table/data', {
+                    method: 'POST',
+                    body: JSON.stringify({
+                        table_name: this.currentTable,
+                        page: this.currentPage,
+                        page_size: this.pageSize
+                    })
+                });
+            }
+            
+            this.totalPages = result.total_pages;
+            this.renderTable(result.data);
+            
+            $('#pageInfo').textContent = `第 ${this.currentPage} / ${this.totalPages} 页 (共 ${result.total} 条)`;
+            $('#prevPage').disabled = this.currentPage <= 1;
+            $('#nextPage').disabled = this.currentPage >= this.totalPages;
+            
+        } catch (error) {
+            container.innerHTML = `<div class="empty-state"><p>加载失败: ${error.message}</p></div>`;
+        }
+    }
+    
+    renderTable(data) {
+        const container = $('#dataTableContainer');
+        
+        if (data.length === 0) {
+            container.innerHTML = '<div class="empty-state"><p>暂无数据</p></div>';
+            return;
+        }
+        
+        const columns = Object.keys(data[0]);
+        
+        container.innerHTML = `
+            <table class="data-table">
+                <thead>
+                    <tr>
+                        ${columns.map(col => `<th>${col}</th>`).join('')}
+                    </tr>
+                </thead>
+                <tbody>
+                    ${data.map(row => `
+                        <tr>
+                            ${columns.map(col => `<td title="${row[col] || ''}">${row[col] ?? ''}</td>`).join('')}
+                        </tr>
+                    `).join('')}
+                </tbody>
+            </table>
+        `;
+    }
+    
+    search() {
+        this.currentPage = 1;
+        this.loadData();
+    }
+    
+    async downloadTable() {
+        if (!this.currentTable) return;
+        try {
+            const response = await fetch('/api/download', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    table_name: this.currentTable,
+                    format: 'xlsx'
+                })
+            });
+            
+            if (!response.ok) {
+                throw new Error('下载失败');
+            }
+            
+            const blob = await response.blob();
+            const url = window.URL.createObjectURL(blob);
+            const a = document.createElement('a');
+            a.href = url;
+            a.download = `${this.currentTable}_${new Date().toISOString().slice(0, 10)}.xlsx`;
+            document.body.appendChild(a);
+            a.click();
+            document.body.removeChild(a);
+            window.URL.revokeObjectURL(url);
+        } catch (error) {
+            showToast(`下载失败: ${error.message}`, 'error');
+        }
+    }
+    
+    async truncateTable() {
+        if (!this.currentTable) return;
+        
+        const confirmed = await showConfirm('清空表', `确定要清空表 "${this.currentTable}" 的所有数据吗？此操作不可恢复。`);
+        if (!confirmed) return;
+        
+        try {
+            await api('/database/table/truncate', {
+                method: 'POST',
+                body: JSON.stringify({ table_name: this.currentTable })
+            });
+            showToast('表已清空', 'success');
+            this.loadData();
+        } catch (error) {
+            showToast(`清空失败: ${error.message}`, 'error');
+        }
+    }
+    
+    async dropTable() {
+        if (!this.currentTable) return;
+        
+        const confirmed = await showConfirm('删除表', `确定要删除表 "${this.currentTable}" 吗？此操作不可恢复。`);
+        if (!confirmed) return;
+        
+        try {
+            await api('/database/table/drop', {
+                method: 'POST',
+                body: JSON.stringify({ table_name: this.currentTable })
+            });
+            showToast('表已删除', 'success');
+            this.currentTable = null;
+            $('#dbToolbar').style.display = 'none';
+            $('#pagination').style.display = 'none';
+            $('#dataTableContainer').innerHTML = '<div class="empty-state"><span class="empty-icon">👈</span><p>请选择左侧的数据表</p></div>';
+            this.loadTables();
+        } catch (error) {
+            showToast(`删除失败: ${error.message}`, 'error');
+        }
+    }
+}
+
+
+// ==================== 设置管理 ====================
+
+class SettingsManager {
+    constructor() {
+        this.sheetFilters = [];
+        this.extractFields = [];
+        this.init();
+    }
+    
+    init() {
+        // 数据库配置保存
+        $('#saveMysqlConfig').addEventListener('click', () => this.saveMysqlConfig());
+        $('#testDbConnection').addEventListener('click', () => this.testConnection());
+        
+        // 密码显示/隐藏
+        $('#togglePassword').addEventListener('click', () => this.togglePasswordVisibility());
+        
+        // Sheet 过滤规则
+        $('#addSheetFilter').addEventListener('click', () => this.addSheetFilter());
+        $('#newSheetFilter').addEventListener('keyup', (e) => {
+            if (e.key === 'Enter') this.addSheetFilter();
+        });
+        $('#saveSheetFilter').addEventListener('click', () => this.saveSheetFilters());
+        
+        // 字段映射
+        $('#addFieldMapping').addEventListener('click', () => this.addFieldMapping());
+        $('#saveFieldMapping').addEventListener('click', () => this.saveFieldMappings());
+        
+        window.addEventListener('pagechange', (e) => {
+            if (e.detail.page === 'settings') {
+                this.loadConfig();
+            }
+        });
+    }
+    
+    togglePasswordVisibility() {
+        const input = $('#configPasswd');
+        const icon = $('#togglePassword .eye-icon');
+        
+        if (input.type === 'password') {
+            input.type = 'text';
+            icon.textContent = '🙈';
+        } else {
+            input.type = 'password';
+            icon.textContent = '👁';
+        }
+    }
+    
+    async loadConfig() {
+        try {
+            const config = await api('/config/full');
+            
+            // 数据库配置
+            $('#configHost').value = config.mysql?.host || '';
+            $('#configPort').value = config.mysql?.port || 3306;
+            $('#configDbname').value = config.mysql?.dbname || '';
+            $('#configUser').value = config.mysql?.user || '';
+            $('#configPasswd').value = config.mysql?.passwd || '';
+            $('#configUpdate').textContent = `更新时间: ${config.update || '-'}`;
+            
+            // Sheet 过滤规则
+            this.sheetFilters = config.sheet_filter || [];
+            this.renderSheetFilters();
+            
+            // 字段映射
+            this.extractFields = config.extract_fields || [];
+            this.renderFieldMappings();
+            
+        } catch (error) {
+            showToast(`加载配置失败: ${error.message}`, 'error');
+        }
+    }
+    
+    async saveMysqlConfig() {
+        const data = {
+            host: $('#configHost').value.trim(),
+            port: parseInt($('#configPort').value) || 3306,
+            user: $('#configUser').value.trim(),
+            passwd: $('#configPasswd').value,
+            dbname: $('#configDbname').value.trim()
+        };
+        
+        if (!data.host || !data.user || !data.dbname) {
+            showToast('请填写完整的数据库配置', 'warning');
+            return;
+        }
+        
+        try {
+            const result = await api('/config/mysql', {
+                method: 'POST',
+                body: JSON.stringify(data)
+            });
+            showToast('数据库配置已保存', 'success');
+            $('#configUpdate').textContent = `更新时间: ${result.update}`;
+        } catch (error) {
+            showToast(`保存失败: ${error.message}`, 'error');
+        }
+    }
+    
+    async testConnection() {
+        try {
+            const result = await api('/database/test');
+            if (result.success) {
+                showToast('数据库连接成功', 'success');
+            } else {
+                showToast(`连接失败: ${result.message}`, 'error');
+            }
+        } catch (error) {
+            showToast(`测试失败: ${error.message}`, 'error');
+        }
+    }
+    
+    // ==================== Sheet 过滤规则 ====================
+    
+    renderSheetFilters() {
+        const container = $('#sheetFilterList');
+        if (this.sheetFilters.length === 0) {
+            container.innerHTML = '<div class="empty-hint">暂无过滤规则</div>';
+            return;
+        }
+        
+        container.innerHTML = this.sheetFilters.map((filter, index) => `
+            <div class="filter-item" data-index="${index}">
+                <span class="filter-text">${filter}</span>
+                <button class="btn-icon remove-filter" data-index="${index}" title="删除">✕</button>
+            </div>
+        `).join('');
+        
+        // 绑定删除事件
+        container.querySelectorAll('.remove-filter').forEach(btn => {
+            btn.addEventListener('click', () => {
+                const index = parseInt(btn.dataset.index);
+                this.sheetFilters.splice(index, 1);
+                this.renderSheetFilters();
+            });
+        });
+    }
+    
+    addSheetFilter() {
+        const input = $('#newSheetFilter');
+        const value = input.value.trim();
+        
+        if (!value) {
+            showToast('请输入过滤关键词', 'warning');
+            return;
+        }
+        
+        if (this.sheetFilters.includes(value)) {
+            showToast('该关键词已存在', 'warning');
+            return;
+        }
+        
+        this.sheetFilters.push(value);
+        input.value = '';
+        this.renderSheetFilters();
+    }
+    
+    async saveSheetFilters() {
+        try {
+            const result = await api('/config/sheet-filter', {
+                method: 'POST',
+                body: JSON.stringify(this.sheetFilters)
+            });
+            showToast('Sheet 过滤规则已保存', 'success');
+            $('#configUpdate').textContent = `更新时间: ${result.update}`;
+        } catch (error) {
+            showToast(`保存失败: ${error.message}`, 'error');
+        }
+    }
+    
+    // ==================== 字段映射配置 ====================
+    
+    renderFieldMappings() {
+        const container = $('#fieldMappingList');
+        const countEl = $('#fieldCount');
+        
+        // 更新字段数量显示
+        if (countEl) {
+            countEl.textContent = `${this.extractFields.length} 个字段`;
+        }
+        
+        if (this.extractFields.length === 0) {
+            container.innerHTML = '<div class="empty-hint">暂无字段映射，点击下方按钮添加</div>';
+            return;
+        }
+        
+        container.innerHTML = this.extractFields.map((field, index) => `
+            <div class="field-mapping-item" data-index="${index}">
+                <span class="field-mapping-number">${index + 1}</span>
+                <div class="field-mapping-header">
+                    <div class="field-name">
+                        <label>数据库字段名</label>
+                        <input type="text" class="form-input field-input" value="${field.Field || ''}" 
+                               data-index="${index}" data-prop="Field" placeholder="输入字段名">
+                    </div>
+                    <button class="btn-icon remove-mapping" data-index="${index}" title="删除此映射">✕</button>
+                </div>
+                <div class="extract-list">
+                    <label>提取来源 (${(field.Extract || []).length} 个)</label>
+                    ${(field.Extract || []).length > 0 ? `
+                        <div class="extract-tree" data-index="${index}">
+                            ${(field.Extract || []).map((extract, ei) => `
+                                <div class="extract-tree-item">
+                                    <span class="tree-text">${extract}</span>
+                                    <button class="tree-remove" data-field="${index}" data-extract="${ei}" title="删除">✕</button>
+                                </div>
+                            `).join('')}
+                        </div>
+                    ` : `
+                        <div class="extract-empty">暂无提取来源，请在下方添加</div>
+                    `}
+                    <div class="add-extract-row">
+                        <input type="text" class="form-input extract-input" placeholder="输入 Excel 列名" 
+                               data-index="${index}">
+                        <button class="btn btn-sm btn-outline add-extract" data-index="${index}">添加</button>
+                    </div>
+                </div>
+            </div>
+        `).join('');
+        
+        // 绑定删除映射事件
+        container.querySelectorAll('.remove-mapping').forEach(btn => {
+            btn.addEventListener('click', () => {
+                const index = parseInt(btn.dataset.index);
+                this.extractFields.splice(index, 1);
+                this.renderFieldMappings();
+            });
+        });
+        
+        // 绑定字段名修改事件
+        container.querySelectorAll('.field-input').forEach(input => {
+            input.addEventListener('change', () => {
+                const index = parseInt(input.dataset.index);
+                this.extractFields[index].Field = input.value.trim();
+            });
+        });
+        
+        // 绑定删除提取来源事件
+        container.querySelectorAll('.tree-remove').forEach(btn => {
+            btn.addEventListener('click', () => {
+                const fieldIndex = parseInt(btn.dataset.field);
+                const extractIndex = parseInt(btn.dataset.extract);
+                this.extractFields[fieldIndex].Extract.splice(extractIndex, 1);
+                this.renderFieldMappings();
+            });
+        });
+        
+        // 绑定添加提取来源事件
+        container.querySelectorAll('.add-extract').forEach(btn => {
+            btn.addEventListener('click', () => {
+                const index = parseInt(btn.dataset.index);
+                const input = container.querySelector(`.extract-input[data-index="${index}"]`);
+                const value = input.value.trim();
+                
+                if (!value) return;
+                
+                if (!this.extractFields[index].Extract) {
+                    this.extractFields[index].Extract = [];
+                }
+                
+                if (!this.extractFields[index].Extract.includes(value)) {
+                    this.extractFields[index].Extract.push(value);
+                    this.renderFieldMappings();
+                } else {
+                    showToast('该来源已存在', 'warning');
+                }
+            });
+        });
+        
+        // 绑定回车添加
+        container.querySelectorAll('.extract-input').forEach(input => {
+            input.addEventListener('keyup', (e) => {
+                if (e.key === 'Enter') {
+                    const index = parseInt(input.dataset.index);
+                    container.querySelector(`.add-extract[data-index="${index}"]`).click();
+                }
+            });
+        });
+    }
+    
+    addFieldMapping() {
+        this.extractFields.push({
+            Field: '',
+            Extract: []
+        });
+        this.renderFieldMappings();
+        
+        // 滚动到底部
+        const container = $('#fieldMappingList');
+        container.scrollTop = container.scrollHeight;
+    }
+    
+    async saveFieldMappings() {
+        // 过滤空字段
+        const validFields = this.extractFields.filter(f => f.Field && f.Field.trim());
+        
+        if (validFields.length === 0) {
+            showToast('请至少添加一个有效的字段映射', 'warning');
+            return;
+        }
+        
+        try {
+            const result = await api('/config/extract-fields', {
+                method: 'POST',
+                body: JSON.stringify(validFields)
+            });
+            this.extractFields = validFields;
+            showToast('字段映射配置已保存', 'success');
+            $('#configUpdate').textContent = `更新时间: ${result.update}`;
+        } catch (error) {
+            showToast(`保存失败: ${error.message}`, 'error');
+        }
+    }
+}
+
+
+// ==================== 初始化 ====================
+
+// ==================== Cache 大小显示 ====================
+
+async function updateCacheSize() {
+    const cacheSizeEl = $('#cacheSize');
+    if (!cacheSizeEl) return;
+    
+    try {
+        const result = await api('/cache/size', { method: 'POST' });
+        if (result.success) {
+            cacheSizeEl.textContent = `历史数据: ${result.size_formatted}`;
+        } else {
+            cacheSizeEl.textContent = '计算失败';
+        }
+    } catch (error) {
+        cacheSizeEl.textContent = '计算失败';
+    }
+}
+
+document.addEventListener('DOMContentLoaded', () => {
+    // 主题管理（最先初始化）
+    new ThemeManager();
+    
+    // 其他模块
+    const navigation = new Navigation();
+    window.fileUploader = new FileUploader();
+    new HistoryManager();
+    new DatabaseManager();
+    new SettingsManager();
+    
+    // 恢复上次访问的页面
+    navigation.restorePage();
+    
+    // 历史数据大小已在处理历史页面显示，不再在侧边栏显示
+    
+    console.log('CapacityReport v2.0.0 已加载');
+    
+    // 重启服务按钮事件（使用事件委托，支持所有页面的重启按钮）
+    document.addEventListener('click', async (e) => {
+        if (e.target.closest('.restart-btn') || e.target.closest('#restartService')) {
+            e.preventDefault();
+            e.stopPropagation();
+            
+            const confirmed = await showConfirm(
+                '重启服务',
+                '确定要重启服务吗？这将中断当前所有操作。'
+            );
+            
+            if (!confirmed) return;
+            
+            // 显示加载遮罩
+            showRestartOverlay('正在重启服务...');
+            
+            try {
+                await api('/service/restart', { method: 'POST' });
+            } catch (error) {
+                // 请求可能因为服务重启而失败，这是正常的
+            }
+            
+            // 开始轮询检测服务是否恢复
+            pollServiceStatus();
+        }
+    });
+    
+    // 显示重启加载遮罩
+    function showRestartOverlay(message) {
+        let overlay = $('#restartOverlay');
+        if (overlay) {
+            overlay.querySelector('.restart-overlay-text').textContent = message;
+            overlay.classList.add('active');
+        }
+    }
+    
+    // 隐藏重启加载遮罩
+    function hideRestartOverlay() {
+        let overlay = $('#restartOverlay');
+        if (overlay) {
+            overlay.classList.remove('active');
+        }
+    }
+    
+    // 更新遮罩文字
+    function updateRestartOverlayText(message) {
+        let overlay = $('#restartOverlay');
+        if (overlay) {
+            overlay.querySelector('.restart-overlay-text').textContent = message;
+        }
+    }
+    
+    // 轮询检测服务状态
+    function pollServiceStatus() {
+        let attempts = 0;
+        const maxAttempts = 60; // 最多尝试 60 次（约 5 分钟）
+        const pollInterval = 5000; // 每 5 秒检测一次
+        
+        const checkService = async () => {
+            attempts++;
+            
+            try {
+                const response = await fetch('/api/service/status', {
+                    method: 'GET',
+                    headers: { 'Content-Type': 'application/json' }
+                });
+                
+                if (response.ok) {
+                    // 服务已恢复
+                    updateRestartOverlayText('服务已恢复，正在刷新页面...');
+                    setTimeout(() => {
+                        window.location.reload();
+                    }, 500);
+                    return;
+                }
+            } catch (error) {
+                // 服务还未恢复，继续轮询
+            }
+            
+            if (attempts < maxAttempts) {
+                setTimeout(checkService, pollInterval);
+            } else {
+                // 超时，提示用户手动刷新
+                hideRestartOverlay();
+                showToast('服务重启超时，请手动刷新页面', 'warning');
+            }
+        };
+        
+        // 延迟 3 秒后开始轮询，给服务一些启动时间
+        setTimeout(checkService, 3000);
+    }
+    
+    // 侧边栏折叠功能
+    const sidebar = $('#sidebar');
+    
+    // 从 localStorage 读取折叠状态
+    const isCollapsed = localStorage.getItem('sidebarCollapsed') === 'true';
+    if (isCollapsed && sidebar) {
+        sidebar.classList.add('collapsed');
+    }
+    
+    // 使用事件委托为所有侧边栏切换按钮绑定事件
+    document.addEventListener('click', (e) => {
+        if (e.target.closest('#sidebarToggle') || e.target.closest('.sidebar-toggle')) {
+            e.preventDefault();
+            e.stopPropagation();
+            if (sidebar) {
+                sidebar.classList.toggle('collapsed');
+                const collapsed = sidebar.classList.contains('collapsed');
+                localStorage.setItem('sidebarCollapsed', collapsed ? 'true' : 'false');
+            }
+        }
+    });
+});
diff --git a/supervisord.conf b/supervisord.conf
new file mode 100644
index 0000000..0921bab
--- /dev/null
+++ b/supervisord.conf
@@ -0,0 +1,29 @@
+[supervisord]
+nodaemon=true
+logfile=/var/log/supervisor/supervisord.log
+pidfile=/var/run/supervisord.pid
+childlogdir=/var/log/supervisor
+user=root
+
+[unix_http_server]
+file=/var/run/supervisor.sock
+chmod=0700
+
+[rpcinterface:supervisor]
+supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface
+
+[supervisorctl]
+serverurl=unix:///var/run/supervisor.sock
+
+[program:fastapi]
+command=uvicorn app.main:app --host 0.0.0.0 --port 9081 --workers 1
+directory=/app
+autostart=true
+autorestart=true
+startsecs=5
+startretries=3
+redirect_stderr=true
+stdout_logfile=/var/log/supervisor/fastapi.log
+stdout_logfile_maxbytes=50MB
+stdout_logfile_backups=5
+environment=PYTHONUNBUFFERED=1