1.7.0

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

docs/plans/2026-03-26-report-analysis-dialog-refactor-analysis.md

@@ -0,0 +1,212 @@
+# ReportAnalysisDialog 组件重构分析
+
+## 📊 当前状态分析
+
+### 基本指标
+
+- **总行数**: 948 行
+- **函数/声明**: 9 个
+- **React Hooks**: 20 个使用
+- **职责数量**: 5+ 个主要职责
+
+### 组件职责分析
+
+#### 1. 数据获取与解析 (~150 行)
+
+- `loadAndAnalyzeReports` - 数据加载逻辑
+- `extractReportValues` - 报告内容解析
+- `parseDurationToSeconds` - 时间解析
+
+#### 2. 数据聚合与转换 (~200 行)
+
+- `chartData` useMemo - 按日期聚合
+- `comparisonData` useMemo - 按用户聚合
+- `comparisonChartData` useMemo - 图表数据格式化
+- `allUsers` useMemo - 用户列表提取
+
+#### 3. 状态管理 (~100 行)
+
+- 6 个 useState hooks
+- 5 个 useCallback handlers
+- 复杂的状态交互逻辑
+
+#### 4. UI 控制与交互 (~200 行)
+
+- 指标选择按钮
+- 视图模式切换
+- 用户筛选器
+- 加载/错误状态显示
+
+#### 5. 图表渲染 (~300 行)
+
+- Recharts 图表配置
+- 两个不同的视图模式
+- 自定义 Tooltip 组件
+- 图表样式和布局
+
+## 🎯 重构目标
+
+### 主要问题
+
+1. **单一文件过大**: 难以维护和理解
+2. **职责混乱**: 数据获取、处理、UI 混在一起
+3. **复用性差**: 逻辑和 UI 紧耦合
+4. **测试困难**: 难以单独测试各个部分
+
+### 重构原则
+
+1. **单一职责**: 每个模块只负责一件事
+2. **可复用性**: 提取通用逻辑到 hooks
+3. **可测试性**: 分离逻辑和 UI
+4. **可维护性**: 清晰的文件结构
+
+## 📦 建议的文件结构
+
+```
+src/renderer/src/components/report-analysis/
+├── index.tsx                          # 主组件入口 (~150 行)
+├── hooks/
+│   ├── useReportData.ts              # 数据获取和解析 (~100 行)
+│   ├── useChartData.ts               # 数据聚合和转换 (~150 行)
+│   └── useReportFilters.ts           # 筛选状态管理 (~80 行)
+├── components/
+│   ├── ReportChart.tsx               # 图表组件 (~200 行)
+│   ├── MetricSelector.tsx            # 指标选择器 (~80 行)
+│   ├── ViewModeToggle.tsx            # 视图模式切换 (~50 行)
+│   ├── UserFilter.tsx                # 用户筛选器 (~100 行)
+│   ├── CustomTooltip.tsx             # 自定义 tooltip (~100 行)
+│   ├── ComparisonTooltip.tsx         # 对比 tooltip (~80 行)
+│   └── LoadingState.tsx              # 加载状态组件 (~60 行)
+├── utils/
+│   ├── parser.ts                     # 报告解析工具 (~100 行)
+│   ├── aggregators.ts                # 数据聚合函数 (~120 行)
+│   └── formatters.ts                 # 格式化工具 (~60 行)
+└── types.ts                          # 类型定义 (~80 行)
+```
+
+## 🔧 重构方案
+
+### 方案 A: 完全重构 (推荐)
+
+**优点**: 最大程度的解耦和可维护性
+**缺点**: 需要更多时间，可能引入新问题
+**时间估计**: 2-3 小时
+
+### 方案 B: 渐进式重构
+
+**优点**: 风险较低，可以逐步验证
+**缺点**: 过渡期代码可能不够优雅
+**时间估计**: 1-2 小时
+
+### 方案 C: 最小化重构
+
+**优点**: 改动最小，风险最低
+**缺点**: 解决根本问题有限
+**时间估计**: 30-45 分钟
+
+## 📝 详细重构步骤
+
+### Phase 1: 提取类型和工具函数 (低风险)
+
+1. 创建 `types.ts` - 集中管理所有类型定义
+2. 创建 `utils/parser.ts` - 提取报告解析逻辑
+3. 创建 `utils/aggregators.ts` - 提取数据聚合逻辑
+
+### Phase 2: 提取自定义 Hooks (中风险)
+
+1. 创建 `hooks/useReportData.ts` - 数据获取和解析
+2. 创建 `hooks/useChartData.ts` - 数据聚合和转换
+3. 创建 `hooks/useReportFilters.ts` - 筛选状态管理
+
+### Phase 3: 提取 UI 组件 (中风险)
+
+1. 创建 `components/MetricSelector.tsx`
+2. 创建 `components/ViewModeToggle.tsx`
+3. 创建 `components/UserFilter.tsx`
+4. 创建 `components/ReportChart.tsx`
+
+### Phase 4: 重构主组件 (高风险)
+
+1. 简化 `index.tsx` 只保留组合逻辑
+2. 添加错误边界
+3. 优化加载状态
+
+## 🎯 重构后的预期效果
+
+### 代码行数分布
+
+- 主组件: ~150 行 (减少 84%)
+- 每个 hook: ~80-150 行
+- 每个 UI 组件: ~50-200 行
+- 工具函数: ~60-120 行
+
+### 可维护性提升
+
+- ✅ 单个文件更小，更易理解
+- ✅ 职责清晰，修改影响范围小
+- ✅ 更容易进行单元测试
+- ✅ 可以独立优化各个部分
+
+### 性能影响
+
+- ➡️ 性能基本不变或略有提升
+- ➡️ 代码分割优化可能略微改善首次加载
+- ➡️ 更好的 memoization 机会
+
+## 🚨 风险评估
+
+### 高风险区域
+
+- 图表配置逻辑（Recharts 配置复杂）
+- 数据转换和聚合（业务逻辑密集）
+- 状态同步（多个状态之间的交互）
+
+### 缓解措施
+
+- 保持现有测试通过
+- 逐步重构，每步验证
+- 添加 TypeScript 严格检查
+- 保留原有功能注释
+
+## 📋 验证清单
+
+重构完成后需要验证：
+
+- [ ] 所有现有功能正常工作
+- [ ] 单元测试通过
+- [ ] E2E 测试通过
+- [ ] 类型检查无错误
+- [ ] 性能无明显下降
+- [ ] 代码风格符合规范
+
+## 🤔 建议的实施顺序
+
+### 推荐方案: 渐进式重构 (方案 B)
+
+**第1步**: 提取类型和工具函数 (15分钟)
+
+- 创建类型定义文件
+- 提取解析工具函数
+- 验证编译和测试
+
+**第2步**: 提取自定义 Hooks (30分钟)
+
+- 提取数据获取逻辑
+- 提取数据聚合逻辑
+- 提取筛选状态管理
+- 验证功能正常
+
+**第3步**: 提取 UI 组件 (30分钟)
+
+- 提取控制面板组件
+- 提取图表组件
+- 提取状态显示组件
+- 验证交互正常
+
+**第4步**: 简化主组件 (15分钟)
+
+- 重构为组合式组件
+- 清理代码和注释
+- 最终验证
+
+**总计**: 约 90 分钟，分4个阶段，每个阶段都可以独立验证

docs/releases/1.6.1.md

@@ -0,0 +1,42 @@
+# 1.6.1
+
+## 核心改进
+
+- **重大重构**：将报告分析组件从 948 行单体组件重构为模块化架构，拆分为 11 个专注的模块文件。
+- **代码质量提升**：主组件代码量减少 79%（948 → 200 行），显著提升可维护性和可读性。
+- **架构优化**：分离数据获取、状态管理和 UI 渲染逻辑，遵循单一职责原则。
+
+## 体验优化
+
+- **修复 tooltip 显示问题**：解决执行时间在提示框中重复显示的问题，现在只显示一次格式化后的时间值。
+- **统一时间格式**：所有时间数值统一保留 1 位小数，提升数据显示的一致性和专业度。
+- **优化界面布局**：精简 tooltip 底部信息，避免冗余内容干扰用户视线。
+
+## 性能优化
+
+- **组件渲染优化**：将 tooltip 组件移出父组件并使用 React.memo，减少不必要的重新渲染。
+- **正则表达式优化**：预编译正则表达式模式，避免在循环中重复创建，提升数据处理效率。
+- **状态更新优化**：使用函数式 setState 更新，避免闭包陷阱和过期的状态读取。
+- **回调函数优化**：使用 useCallback 稳定回调函数引用，减少子组件的不必要更新。
+
+## 开发体验
+
+- **模块化设计**：将复杂组件拆分为可复用的 hooks 和 UI 组件，便于单独测试和维护。
+- **类型安全**：完整的 TypeScript 类型定义，提升开发时的类型检查和 IDE 支持。
+- **代码组织**：清晰的文件结构（types、hooks、components、utils），便于团队协作和代码导航。
+- **向后兼容**：保持原有 API 接口不变，现有使用方式无需修改。
+
+## 技术细节
+
+- 应用 Vercel React 最佳实践，包括：
+  - 避免内联组件定义（rerender-no-inline-components）
+  - 提升正则表达式创建位置（js-hoist-regexp）
+  - 使用函数式状态更新（rerender-functional-setState）
+  - 最小化回调依赖项（rerender-dependencies）
+- 新增自定义 hooks：useReportData、useChartData、useReportFilters
+- 新增 UI 组件：MetricSelector、ViewModeToggle、UserFilter、ReportChart
+- 新增工具函数：数据解析器和聚合器
+
+## 破坏性变更
+
+无破坏性变更，所有现有功能保持完全兼容。

docs/releases/1.6.2.md

@@ -0,0 +1,6 @@
+# 1.6.2
+
+## 系统优化
+
+- 简化用户角色体系，移除未使用的 Guest 角色。
+- 优化类型安全性，加强用户认证流程健壮性。

docs/releases/1.7.0.md

@@ -0,0 +1,18 @@
+# 1.7.0
+
+## 核心功能
+
+- 新增提取操作历史记录功能，每次执行提取后自动保存订单号和总排号。
+- 支持查看历史批次详情，包含操作时间、订单数、记录数、成功/失败统计。
+- 批次记录可展开查看，显示总排号与订单号的对应关系。
+
+## 界面与交互
+
+- 提取页面新增"操作历史"按钮，点击打开历史记录对话框。
+- 管理员可查看所有用户的历史记录，普通用户仅查看自己的记录。
+- 支持删除历史批次，管理员可删除任意批次，普通用户仅可删除自己的记录。
+
+## 数据存储
+
+- 新增数据库表 `ExtractorOperationHistory`，支持 SQL Server 和 MySQL。
+- 需执行数据库脚本创建表结构（详见项目文档）。

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "erpauto",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "erpauto",
-      "version": "1.6.0",
+      "version": "1.7.0",
       "hasInstallScript": true,
       "dependencies": {
         "@aws-sdk/client-s3": "^3.929.0",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "erpauto",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "An Electron application with React and TypeScript",
   "main": "./out/main/index.js",
   "author": "example.com",

src/main/ipc/extractor-handler.ts

@@ -3,6 +3,7 @@ import { ErpAuthService } from '../services/erp/erp-auth'
 import { ExtractorService } from '../services/erp/extractor'
 import { OrderNumberResolver } from '../services/erp/order-resolver'
 import { create, type IDatabaseService } from '../services/database'
+import { ExtractorOperationHistoryDAO } from '../services/database/extractor-operation-history-dao'
 import { createLogger } from '../services/logger'
 import { logAudit } from '../services/logger/audit-logger'
 import { SessionManager } from '../services/user/session-manager'
@@ -12,6 +13,7 @@ import type { ExtractorInput, ExtractorResult, ExtractionProgress } from '../typ
 import { UserErpConfigService } from '../services/user/user-erp-config-service'
 import { ConfigManager } from '../services/config/config-manager'
 import { IPC_CHANNELS } from '../../shared/ipc-channels'
+import { randomUUID } from 'crypto'
 
 const log = createLogger('ExtractorHandler')
 
@@ -141,6 +143,29 @@ export function registerExtractorHandlers(): void {
 
           log.info('Resolved order numbers', { count: validOrderNumbers.length })
 
+          // Initialize operation history recording
+          const currentUser = SessionManager.getInstance().getUserInfo()
+          const historyDao = new ExtractorOperationHistoryDAO()
+          const batchId = randomUUID()
+
+          // Save order records to history (preserve productionId -> orderNumber mapping)
+          if (currentUser) {
+            const orderRecords = mappings.map((m) => ({
+              productionId: m.productionId || null,
+              orderNumber: m.orderNumber || m.input
+            }))
+            await historyDao.insertBatchRecords(
+              batchId,
+              currentUser.id,
+              currentUser.username,
+              orderRecords
+            )
+            log.info('Operation history batch created', {
+              batchId,
+              recordCount: orderRecords.length
+            })
+          }
+
           // Log deduplication summary
           sendLog(sender, 'info', dedupReport.summary)
 
@@ -223,11 +248,22 @@ export function registerExtractorHandlers(): void {
             })
           }
 
+          // Update operation history batch status
+          if (currentUser) {
+            const status: 'success' | 'failed' | 'partial' =
+              result.errors.length > 0 && result.recordCount > 0
+                ? 'partial'
+                : result.errors.length > 0
+                  ? 'failed'
+                  : 'success'
+            await historyDao.updateBatchStatus(batchId, status, result.recordCount)
+            log.info('Operation history batch status updated', { batchId, status })
+          }
+
           // Audit log: EXTRACT (non-blocking)
           const os = await import('os')
-          const currentUser = SessionManager.getInstance().getUserInfo()
           if (currentUser) {
-            const status: 'success' | 'failure' | 'partial' =
+            const auditStatus: 'success' | 'failure' | 'partial' =
               result.errors.length > 0 && result.recordCount > 0
                 ? 'partial'
                 : result.errors.length > 0
@@ -237,7 +273,7 @@ export function registerExtractorHandlers(): void {
               username: currentUser.username,
               computerName: os.hostname(),
               resource: 'MATERIAL_PLAN',
-              status,
+              status: auditStatus,
               metadata: {
                 orderCount: validOrderNumbers.length,
                 recordCount: result.recordCount,

src/main/ipc/index.ts

@@ -17,6 +17,7 @@ import { registerLoggerHandlers } from './logger-handler'
 import { registerReportHandlers } from './report-handler'
 import { registerUpdateHandlers } from './update-handler'
 import { registerPlaywrightBrowserHandlers } from './playwright-browser'
+import { registerOperationHistoryHandlers } from './operation-history-handler'
 import { createLogger, logError } from '../services/logger'
 import { serializeError, sanitizeError } from '../services/logger/error-utils'
 import { getErrorMessage, getErrorCode, isBaseError } from '../types/errors'
@@ -107,5 +108,6 @@ export function registerIpcHandlers(): void {
   registerReportHandlers()
   registerUpdateHandlers()
   registerPlaywrightBrowserHandlers()
+  registerOperationHistoryHandlers()
   log.info('All IPC handlers registered')
 }

src/main/ipc/operation-history-handler.ts

@@ -0,0 +1,124 @@
+/**
+ * IPC Handler for Extractor Operation History
+ *
+ * Handles IPC requests for operation history management:
+ * - Get batch list (filtered by user for non-admin users)
+ * - Get batch details
+ * - Delete batches
+ */
+
+import { ipcMain } from 'electron'
+import { ExtractorOperationHistoryDAO } from '../services/database/extractor-operation-history-dao'
+import { SessionManager } from '../services/user/session-manager'
+import { withErrorHandling, type IpcResult } from './index'
+import { IPC_CHANNELS } from '../../shared/ipc-channels'
+import { createLogger } from '../services/logger'
+import type {
+  BatchStats,
+  OperationHistoryRecord,
+  GetBatchesOptions
+} from '../types/operation-history.types'
+
+const log = createLogger('OperationHistoryHandler')
+
+/**
+ * Register IPC handlers for operation history
+ */
+export function registerOperationHistoryHandlers(): void {
+  const dao = new ExtractorOperationHistoryDAO()
+
+  /**
+   * Get batches list
+   * Admin users get all batches, regular users get only their own
+   */
+  ipcMain.handle(
+    IPC_CHANNELS.OPERATION_HISTORY_GET_BATCHES,
+    async (event, options?: GetBatchesOptions): Promise<IpcResult<BatchStats[]>> => {
+      return withErrorHandling(async () => {
+        const currentUser = SessionManager.getInstance().getUserInfo()
+
+        if (!currentUser) {
+          throw new Error('用户未登录')
+        }
+
+        // Admin gets all batches, User gets only their own
+        const userId = currentUser.userType === 'Admin' ? undefined : currentUser.id
+
+        log.info('Getting operation history batches', {
+          userId: currentUser.id,
+          userType: currentUser.userType,
+          filtered: userId !== undefined
+        })
+
+        const batches = await dao.getBatches(userId, options)
+        return batches
+      }, 'operationHistory:getBatches')
+    }
+  )
+
+  /**
+   * Get batch details
+   * Users can only view their own batch details, admins can view all
+   */
+  ipcMain.handle(
+    IPC_CHANNELS.OPERATION_HISTORY_GET_BATCH_DETAILS,
+    async (event, batchId: string): Promise<IpcResult<OperationHistoryRecord[]>> => {
+      return withErrorHandling(async () => {
+        const currentUser = SessionManager.getInstance().getUserInfo()
+
+        if (!currentUser) {
+          throw new Error('用户未登录')
+        }
+
+        log.info('Getting batch details', { batchId, userId: currentUser.id })
+
+        const details = await dao.getBatchDetails(batchId)
+
+        // For non-admin users, verify they own this batch
+        if (currentUser.userType !== 'Admin' && details.length > 0) {
+          const batchOwnerId = details[0].userId
+          if (batchOwnerId !== currentUser.id) {
+            throw new Error('没有权限查看此批次详情')
+          }
+        }
+
+        return details
+      }, 'operationHistory:getBatchDetails')
+    }
+  )
+
+  /**
+   * Delete a batch
+   * Users can only delete their own batches, admins can delete any
+   */
+  ipcMain.handle(
+    IPC_CHANNELS.OPERATION_HISTORY_DELETE_BATCH,
+    async (event, batchId: string): Promise<IpcResult<{ deleted: boolean }>> => {
+      return withErrorHandling(async () => {
+        const currentUser = SessionManager.getInstance().getUserInfo()
+
+        if (!currentUser) {
+          throw new Error('用户未登录')
+        }
+
+        const isAdmin = currentUser.userType === 'Admin'
+
+        log.info('Deleting batch', {
+          batchId,
+          userId: currentUser.id,
+          isAdmin
+        })
+
+        const result = await dao.deleteBatch(batchId, currentUser.id, isAdmin)
+
+        if (!result.success) {
+          throw new Error(result.error || '删除批次失败')
+        }
+
+        return { deleted: true }
+      }, 'operationHistory:deleteBatch')
+    }
+  )
+
+  log.info('Operation history IPC handlers registered')
+}

src/main/ipc/settings-handler.ts

@@ -28,7 +28,13 @@ export function registerSettingsHandlers(): void {
 
   ipcMain.handle(IPC_CHANNELS.SETTINGS_GET_USER_TYPE, async (): Promise<IpcResult<UserType>> => {
     return withErrorHandling(
-      async () => (sessionManager.getUserType() as UserType) || 'Guest',
+      async () => {
+        const userType = sessionManager.getUserType()
+        if (!userType) {
+          throw new ValidationError('未找到用户类型', 'VAL_INVALID_INPUT')
+        }
+        return userType as UserType
+      },
       'settings:getUserType'
     )
   })

src/main/schemas/auth.schema.ts

@@ -20,7 +20,7 @@ export type LoginRequestZod = z.infer<typeof LoginRequestSchema>
 export const UserInfoSchema = z.object({
   id: z.number().int().positive(),
   username: z.string().min(1),
-  userType: z.enum(['Admin', 'User', 'Guest']),
+  userType: z.enum(['Admin', 'User']),
   computerName: z.string().optional()
 })
 

src/main/services/database/extractor-operation-history-dao.ts

@@ -0,0 +1,607 @@
+/**
+ * Data Access Object for ExtractorOperationHistory table
+ *
+ * Handles database operations for tracking extraction operation history:
+ * - Batch record insertion
+ * - Batch status updates
+ * - Querying batches (with user filtering for non-admin users)
+ * - Getting batch details
+ * - Deleting batches
+ */
+
+import { create, type IDatabaseService } from './index'
+import { createLogger } from '../logger'
+import type {
+  OperationHistoryRecord,
+  BatchStats,
+  InsertBatchRecordInput,
+  UpdateBatchStatusResult,
+  GetBatchesOptions
+} from '../../types/operation-history.types'
+
+const log = createLogger('ExtractorOperationHistoryDAO')
+
+/**
+ * Configuration for ExtractorOperationHistory table
+ */
+export const EXTRACTOR_OPERATION_HISTORY_CONFIG = {
+  TABLE_NAME_SQLSERVER: '[dbo].[ExtractorOperationHistory]',
+  TABLE_NAME_MYSQL: 'dbo_ExtractorOperationHistory',
+  COLUMNS: {
+    ID: 'ID',
+    BATCH_ID: 'BatchId',
+    USER_ID: 'UserId',
+    USERNAME: 'Username',
+    PRODUCTION_ID: 'ProductionId',
+    ORDER_NUMBER: 'OrderNumber',
+    OPERATION_TIME: 'OperationTime',
+    STATUS: 'Status',
+    RECORD_COUNT: 'RecordCount',
+    ERROR_MESSAGE: 'ErrorMessage'
+  }
+} as const
+
+/**
+ * ExtractorOperationHistory DAO Class
+ */
+export class ExtractorOperationHistoryDAO {
+  private dbService: IDatabaseService | null = null
+
+  /**
+   * Get the appropriate table name based on database type
+   */
+  private getTableName(): string {
+    const isSqlServer = this.dbService?.type === 'sqlserver'
+    return isSqlServer
+      ? EXTRACTOR_OPERATION_HISTORY_CONFIG.TABLE_NAME_SQLSERVER
+      : EXTRACTOR_OPERATION_HISTORY_CONFIG.TABLE_NAME_MYSQL
+  }
+
+  /**
+   * Get database service instance using DatabaseFactory
+   */
+  private async getDatabaseService(): Promise<IDatabaseService> {
+    if (this.dbService && this.dbService.isConnected()) {
+      return this.dbService
+    }
+
+    this.dbService = await create()
+    return this.dbService
+  }
+
+  /**
+   * Build placeholders for IN clause based on database type
+   */
+  private buildPlaceholders(count: number, isSqlServer: boolean): string {
+    return isSqlServer
+      ? Array.from({ length: count }, (_, idx) => `@p${idx}`).join(',')
+      : Array.from({ length: count }, () => '?').join(',')
+  }
+
+  // ==================== INSERT ====================
+
+  /**
+   * Insert batch records for a single extraction operation
+   * @param batchId - Unique batch identifier
+   * @param userId - User ID performing the operation
+   * @param username - Username performing the operation
+   * @param records - Array of order records to insert
+   * @returns True if successful
+   */
+  async insertBatchRecords(
+    batchId: string,
+    userId: number,
+    username: string,
+    records: InsertBatchRecordInput[]
+  ): Promise<boolean> {
+    if (!records || records.length === 0) {
+      log.warn('No records to insert')
+      return false
+    }
+
+    try {
+      const dbService = await this.getDatabaseService()
+      const tableName = this.getTableName()
+      const isSqlServer = dbService.type === 'sqlserver'
+
+      for (const record of records) {
+        try {
+          if (isSqlServer) {
+            const sqlString = `
+              INSERT INTO ${tableName}
+                (BatchId, UserId, Username, ProductionId, OrderNumber, OperationTime, Status)
+              VALUES
+                (@p0, @p1, @p2, @p3, @p4, GETDATE(), 'pending')
+            `
+            await dbService.query(sqlString, [
+              batchId,
+              userId,
+              username,
+              record.productionId || null,
+              record.orderNumber
+            ])
+          } else {
+            const sqlString = `
+              INSERT INTO ${tableName}
+                (BatchId, UserId, Username, ProductionId, OrderNumber, OperationTime, Status)
+              VALUES
+                (?, ?, ?, ?, ?, NOW(), 'pending')
+            `
+            await dbService.query(sqlString, [
+              batchId,
+              userId,
+              username,
+              record.productionId || null,
+              record.orderNumber
+            ])
+          }
+        } catch (error) {
+          log.error('Error inserting individual record', {
+            batchId,
+            orderNumber: record.orderNumber,
+            error: error instanceof Error ? error.message : String(error)
+          })
+        }
+      }
+
+      log.info('Batch records inserted', { batchId, count: records.length })
+      return true
+    } catch (error) {
+      log.error('Insert batch records error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
+      return false
+    }
+  }
+
+  // ==================== UPDATE ====================
+
+  /**
+   * Update the status of all records in a batch
+   * @param batchId - Batch identifier
+   * @param status - New status (success, failed, partial)
+   * @param recordCount - Total record count for the batch
+   * @returns Update result
+   */
+  async updateBatchStatus(
+    batchId: string,
+    status: string,
+    recordCount: number | null
+  ): Promise<UpdateBatchStatusResult> {
+    try {
+      const dbService = await this.getDatabaseService()
+      const tableName = this.getTableName()
+      const isSqlServer = dbService.type === 'sqlserver'
+
+      const placeholder = isSqlServer ? '@p0' : '?'
+      let sqlString: string
+      let params: (string | number | null)[]
+
+      if (recordCount !== null) {
+        sqlString = `
+          UPDATE ${tableName}
+          SET Status = ${isSqlServer ? '@p0' : '?'},
+              RecordCount = ${isSqlServer ? '@p1' : '?'}
+          WHERE BatchId = ${isSqlServer ? '@p2' : '?'}
+        `
+        params = isSqlServer ? [status, recordCount, batchId] : [status, recordCount, batchId]
+      } else {
+        sqlString = `
+          UPDATE ${tableName}
+          SET Status = ${placeholder}
+          WHERE BatchId = ${isSqlServer ? '@p1' : '?'}
+        `
+        params = isSqlServer ? [status, batchId] : [status, batchId]
+      }
+
+      await dbService.query(sqlString, params)
+
+      log.info('Batch status updated', { batchId, status, recordCount })
+      return { success: true, updatedCount: 1 }
+    } catch (error) {
+      log.error('Update batch status error', {
+        batchId,
+        error: error instanceof Error ? error.message : String(error)
+      })
+      return { success: false, updatedCount: 0 }
+    }
+  }
+
+  /**
+   * Update a single record's status and error message
+   * @param batchId - Batch identifier
+   * @param orderNumber - Order number
+   * @param status - New status
+   * @param errorMessage - Optional error message
+   * @returns True if successful
+   */
+  async updateRecordStatus(
+    batchId: string,
+    orderNumber: string,
+    status: string,
+    errorMessage?: string
+  ): Promise<boolean> {
+    try {
+      const dbService = await this.getDatabaseService()
+      const tableName = this.getTableName()
+      const isSqlServer = dbService.type === 'sqlserver'
+
+      const sqlString = `
+        UPDATE ${tableName}
+        SET Status = ${isSqlServer ? '@p0' : '?'},
+            ErrorMessage = ${isSqlServer ? '@p1' : '?'}
+        WHERE BatchId = ${isSqlServer ? '@p2' : '?'}
+          AND OrderNumber = ${isSqlServer ? '@p3' : '?'}
+      `
+
+      await dbService.query(sqlString, [status, errorMessage || null, batchId, orderNumber])
+
+      return true
+    } catch (error) {
+      log.error('Update record status error', {
+        batchId,
+        orderNumber,
+        error: error instanceof Error ? error.message : String(error)
+      })
+      return false
+    }
+  }
+
+  // ==================== READ ====================
+
+  /**
+   * Get batch statistics with optional user filtering
+   * @param userId - Optional user ID for filtering (Admin gets all, User gets own)
+   * @param options - Query options (limit, offset)
+   * @returns Array of batch statistics
+   */
+  async getBatches(userId?: number, options?: GetBatchesOptions): Promise<BatchStats[]> {
+    try {
+      const dbService = await this.getDatabaseService()
+      const tableName = this.getTableName()
+      const isSqlServer = dbService.type === 'sqlserver'
+
+      let sqlString = `
+        SELECT
+          BatchId,
+          UserId,
+          Username,
+          MIN(OperationTime) as OperationTime,
+          MAX(Status) as Status,
+          COUNT(*) as TotalOrders,
+          SUM(COALESCE(RecordCount, 0)) as TotalRecords,
+          SUM(CASE WHEN Status = 'success' THEN 1 ELSE 0 END) as SuccessCount,
+          SUM(CASE WHEN Status = 'failed' THEN 1 ELSE 0 END) as FailedCount
+        FROM ${tableName}
+      `
+
+      const params: (number | string)[] = []
+
+      if (userId !== undefined) {
+        sqlString += isSqlServer ? ` WHERE UserId = @p0 ` : ` WHERE UserId = ? `
+        params.push(userId)
+      }
+
+      sqlString += `
+        GROUP BY BatchId, UserId, Username
+        ORDER BY OperationTime DESC
+      `
+
+      if (options?.limit) {
+        // Add pagination - track current param count before adding new params
+        const offsetIndex = params.length
+        const limitIndex = params.length + 1
+
+        if (options.offset !== undefined) {
+          params.push(options.offset)
+        }
+        params.push(options.limit)
+
+        if (isSqlServer) {
+          if (options.offset !== undefined) {
+            sqlString += ` OFFSET @p${offsetIndex} ROWS FETCH NEXT @p${limitIndex} ROWS ONLY`
+          } else {
+            // When no offset, use 0 for offset and next index for limit
+            sqlString += ` OFFSET 0 ROWS FETCH NEXT @p${offsetIndex} ROWS ONLY`
+          }
+        } else {
+          if (options.offset !== undefined) {
+            sqlString += ` LIMIT ?`
+            // For MySQL with offset, we need to modify the query
+            // Replace LIMIT with OFFSET LIMIT
+            const parts = sqlString.split(' LIMIT ?')
+            sqlString = parts[0] + ` OFFSET ? LIMIT ?` + (parts[1] || '')
+          } else {
+            sqlString += ` LIMIT ?`
+          }
+        }
+      }
+
+      const result = await dbService.query(sqlString, params)
+
+      return result.rows.map((row) => ({
+        batchId: row.BatchId as string,
+        userId: row.UserId as number,
+        username: row.Username as string,
+        operationTime: row.OperationTime
+          ? new Date(row.OperationTime as string).toISOString()
+          : new Date().toISOString(),
+        status: row.Status as string,
+        totalOrders: row.TotalOrders as number,
+        totalRecords: (row.TotalRecords as number) || 0,
+        successCount: (row.SuccessCount as number) || 0,
+        failedCount: (row.FailedCount as number) || 0
+      }))
+    } catch (error) {
+      log.error('Get batches error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
+      return []
+    }
+  }
+
+  /**
+   * Get detailed records for a specific batch
+   * @param batchId - Batch identifier
+   * @returns Array of operation records
+   */
+  async getBatchDetails(batchId: string): Promise<OperationHistoryRecord[]> {
+    try {
+      const dbService = await this.getDatabaseService()
+      const tableName = this.getTableName()
+      const isSqlServer = dbService.type === 'sqlserver'
+
+      const placeholder = isSqlServer ? '@p0' : '?'
+      const sqlString = `
+        SELECT
+          ID,
+          BatchId,
+          UserId,
+          Username,
+          ProductionId,
+          OrderNumber,
+          OperationTime,
+          Status,
+          RecordCount,
+          ErrorMessage
+        FROM ${tableName}
+        WHERE BatchId = ${placeholder}
+        ORDER BY ID
+      `
+
+      const result = await dbService.query(sqlString, [batchId])
+
+      return result.rows.map((row) => ({
+        id: row.ID as number,
+        batchId: row.BatchId as string,
+        userId: row.UserId as number,
+        username: row.Username as string,
+        productionId: row.ProductionId as string | null,
+        orderNumber: row.OrderNumber as string,
+        operationTime: new Date(row.OperationTime as string),
+        status: row.Status as string,
+        recordCount: row.RecordCount as number | null,
+        errorMessage: row.ErrorMessage as string | null
+      }))
+    } catch (error) {
+      log.error('Get batch details error', {
+        batchId,
+        error: error instanceof Error ? error.message : String(error)
+      })
+      return []
+    }
+  }
+
+  /**
+   * Get a single batch's statistics
+   * @param batchId - Batch identifier
+   * @returns Batch statistics or null
+   */
+  async getBatchStats(batchId: string): Promise<BatchStats | null> {
+    try {
+      const dbService = await this.getDatabaseService()
+      const tableName = this.getTableName()
+      const isSqlServer = dbService.type === 'sqlserver'
+
+      const placeholder = isSqlServer ? '@p0' : '?'
+      const sqlString = `
+        SELECT
+          BatchId,
+          UserId,
+          Username,
+          MIN(OperationTime) as OperationTime,
+          MAX(Status) as Status,
+          COUNT(*) as TotalOrders,
+          SUM(COALESCE(RecordCount, 0)) as TotalRecords,
+          SUM(CASE WHEN Status = 'success' THEN 1 ELSE 0 END) as SuccessCount,
+          SUM(CASE WHEN Status = 'failed' THEN 1 ELSE 0 END) as FailedCount
+        FROM ${tableName}
+        WHERE BatchId = ${placeholder}
+        GROUP BY BatchId, UserId, Username
+      `
+
+      const result = await dbService.query(sqlString, [batchId])
+
+      if (result.rows.length === 0) {
+        return null
+      }
+
+      const row = result.rows[0]
+      return {
+        batchId: row.BatchId as string,
+        userId: row.UserId as number,
+        username: row.Username as string,
+        operationTime: row.OperationTime
+          ? new Date(row.OperationTime as string).toISOString()
+          : new Date().toISOString(),
+        status: row.Status as string,
+        totalOrders: row.TotalOrders as number,
+        totalRecords: (row.TotalRecords as number) || 0,
+        successCount: (row.SuccessCount as number) || 0,
+        failedCount: (row.FailedCount as number) || 0
+      }
+    } catch (error) {
+      log.error('Get batch stats error', {
+        batchId,
+        error: error instanceof Error ? error.message : String(error)
+      })
+      return null
+    }
+  }
+
+  // ==================== DELETE ====================
+
+  /**
+   * Delete a batch with permission checking
+   * @param batchId - Batch identifier
+   * @param requestingUserId - User ID requesting the deletion
+   * @param isAdmin - Whether the requesting user is an admin
+   * @returns True if successful
+   */
+  async deleteBatch(
+    batchId: string,
+    requestingUserId: number,
+    isAdmin: boolean
+  ): Promise<{ success: boolean; error?: string }> {
+    try {
+      const dbService = await this.getDatabaseService()
+      const tableName = this.getTableName()
+      const isSqlServer = dbService.type === 'sqlserver'
+
+      // First check if the batch exists and if the user has permission
+      const batchStats = await this.getBatchStats(batchId)
+
+      if (!batchStats) {
+        return { success: false, error: '批次不存在' }
+      }
+
+      // Non-admin users can only delete their own batches
+      if (!isAdmin && batchStats.userId !== requestingUserId) {
+        return { success: false, error: '没有权限删除此批次' }
+      }
+
+      // Delete the batch
+      const placeholder = isSqlServer ? '@p0' : '?'
+      const sqlString = `
+        DELETE FROM ${tableName}
+        WHERE BatchId = ${placeholder}
+      `
+
+      const result = await dbService.query(sqlString, [batchId])
+
+      log.info('Batch deleted', { batchId, rowCount: result.rowCount })
+      return { success: true }
+    } catch (error) {
+      log.error('Delete batch error', {
+        batchId,
+        error: error instanceof Error ? error.message : String(error)
+      })
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      }
+    }
+  }
+
+  /**
+   * Delete all batches for a specific user
+   * @param userId - User ID
+   * @returns Number of batches deleted
+   */
+  async deleteByUser(userId: number): Promise<number> {
+    try {
+      const dbService = await this.getDatabaseService()
+      const tableName = this.getTableName()
+      const isSqlServer = dbService.type === 'sqlserver'
+
+      const placeholder = isSqlServer ? '@p0' : '?'
+      const sqlString = `
+        DELETE FROM ${tableName}
+        WHERE UserId = ${placeholder}
+      `
+
+      const result = await dbService.query(sqlString, [userId])
+      return result.rowCount
+    } catch (error) {
+      log.error('Delete by user error', {
+        userId,
+        error: error instanceof Error ? error.message : String(error)
+      })
+      return 0
+    }
+  }
+
+  // ==================== UTILITIES ====================
+
+  /**
+   * Check if a batch exists
+   * @param batchId - Batch identifier
+   * @returns True if batch exists
+   */
+  async batchExists(batchId: string): Promise<boolean> {
+    try {
+      const dbService = await this.getDatabaseService()
+      const tableName = this.getTableName()
+      const isSqlServer = dbService.type === 'sqlserver'
+
+      const placeholder = isSqlServer ? '@p0' : '?'
+      const sqlString = `
+        SELECT COUNT(*) as count
+        FROM ${tableName}
+        WHERE BatchId = ${placeholder}
+      `
+
+      const result = await dbService.query(sqlString, [batchId])
+      return result.rows.length > 0 && (result.rows[0].count as number) > 0
+    } catch (error) {
+      log.error('Batch exists error', {
+        batchId,
+        error: error instanceof Error ? error.message : String(error)
+      })
+      return false
+    }
+  }
+
+  /**
+   * Count total batches with optional user filtering
+   * @param userId - Optional user ID for filtering
+   * @returns Total number of batches
+   */
+  async countBatches(userId?: number): Promise<number> {
+    try {
+      const dbService = await this.getDatabaseService()
+      const tableName = this.getTableName()
+      const isSqlServer = dbService.type === 'sqlserver'
+
+      let sqlString = `
+        SELECT COUNT(DISTINCT BatchId) as count
+        FROM ${tableName}
+      `
+
+      const params: number[] = []
+
+      if (userId !== undefined) {
+        sqlString += isSqlServer ? ` WHERE UserId = @p0 ` : ` WHERE UserId = ? `
+        params.push(userId)
+      }
+
+      const result = await dbService.query(sqlString, params)
+      return result.rows.length > 0 ? (result.rows[0].count as number) : 0
+    } catch (error) {
+      log.error('Count batches error', {
+        error: error instanceof Error ? error.message : String(error)
+      })
+      return 0
+    }
+  }
+
+  /**
+   * Disconnect from database
+   */
+  async disconnect(): Promise<void> {
+    if (this.dbService) {
+      await this.dbService.disconnect()
+      this.dbService = null
+    }
+  }
+}

src/main/services/update/update-catalog-service.ts

@@ -29,7 +29,7 @@ export class UpdateCatalogService {
 
   public getDialogCatalog(status: UpdateStatus, catalog: UpdateCatalog): UpdateDialogCatalog {
     const currentUserType = status.currentUserType
-    if (!status.enabled || !currentUserType || currentUserType === 'Guest') {
+    if (!status.enabled || !currentUserType) {
       return { mode: 'disabled' }
     }
 

src/main/services/update/update-service.ts

@@ -106,7 +106,7 @@ export class UpdateService {
     this.ensureInitialized()
     this.status.currentUserType = userType
 
-    if (!this.status.enabled || !userType || userType === 'Guest') {
+    if (!this.status.enabled || !userType) {
       this.clearPolling()
       this.catalog = { stable: [], preview: [] }
       this.publishStatus({

src/main/services/user/bip-users-dao.ts

@@ -139,7 +139,7 @@ export class BIPUsersDAO {
           return {
             id: row.ID as number,
             username: row.UserName as string,
-            userType: row.UserType as 'Admin' | 'User' | 'Guest'
+            userType: row.UserType as 'Admin' | 'User'
           }
         }
         return null
@@ -157,7 +157,7 @@ export class BIPUsersDAO {
           return {
             id: row.ID as number,
             username: row.UserName as string,
-            userType: row.UserType as 'Admin' | 'User' | 'Guest'
+            userType: row.UserType as 'Admin' | 'User'
           }
         }
         return null
@@ -198,7 +198,7 @@ export class BIPUsersDAO {
           return {
             id: row.ID as number,
             username: row.UserName as string,
-            userType: row.UserType as 'Admin' | 'User' | 'Guest'
+            userType: row.UserType as 'Admin' | 'User'
           }
         }
         return null
@@ -216,7 +216,7 @@ export class BIPUsersDAO {
           return {
             id: row.ID as number,
             username: row.UserName as string,
-            userType: row.UserType as 'Admin' | 'User' | 'Guest'
+            userType: row.UserType as 'Admin' | 'User'
           }
         }
         return null
@@ -254,7 +254,7 @@ export class BIPUsersDAO {
       return result.rows.map((row) => ({
         id: row.ID as number,
         username: row.UserName as string,
-        userType: row.UserType as 'Admin' | 'User' | 'Guest',
+        userType: row.UserType as 'Admin' | 'User',
         createTime: row.CreateTime as Date | undefined
       }))
     } catch (error) {
@@ -270,7 +270,7 @@ export class BIPUsersDAO {
    * Create a new user
    * @param username - The username (must be unique)
    * @param password - The password
-   * @param userType - User type ('Admin', 'User', or 'Guest')
+   * @param userType - User type ('Admin' or 'User')
    * @param computerName - Optional computer name for silent login
    * @returns True if successful
    */

src/main/services/user/session-manager.ts

@@ -126,13 +126,6 @@ export class SessionManager {
     return this.currentUser?.userType === 'Admin'
   }
 
-  /**
-   * Check if the current user is a guest
-   */
-  public isGuest(): boolean {
-    return this.currentUser?.userType === 'Guest'
-  }
-
   /**
    * Get the current username
    */

src/main/types/operation-history.types.ts

@@ -0,0 +1,86 @@
+/**
+ * Operation History Type Definitions
+ *
+ * Type definitions for the Extractor Operation History feature.
+ * Tracks extraction operations with batch and individual order record details.
+ */
+
+/**
+ * Individual operation history record
+ */
+export interface OperationHistoryRecord {
+  /** Auto-increment ID */
+  id?: number
+  /** Batch ID - shared among all orders in a single extraction operation */
+  batchId: string
+  /** User ID who performed the operation */
+  userId: number
+  /** Username who performed the operation */
+  username: string
+  /** Original input production ID (e.g., "22A1"), null if input was already an order number */
+  productionId: string | null
+  /** Resolved order number (e.g., "SC70202602120085") */
+  orderNumber: string
+  /** When the operation was performed */
+  operationTime: Date
+  /** Operation status: pending, success, failed, partial */
+  status: string
+  /** Number of records extracted for this order */
+  recordCount: number | null
+  /** Error message if operation failed */
+  errorMessage: string | null
+}
+
+/**
+ * Batch statistics - aggregated view of a batch operation
+ */
+export interface BatchStats {
+  /** Unique batch identifier */
+  batchId: string
+  /** User ID who performed the operation */
+  userId: number
+  /** Username who performed the operation */
+  username: string
+  /** When the operation started */
+  operationTime: string
+  /** Overall batch status: pending, success, failed, partial */
+  status: string
+  /** Total number of orders in the batch */
+  totalOrders: number
+  /** Total records extracted across all orders */
+  totalRecords: number
+  /** Number of orders that succeeded */
+  successCount: number
+  /** Number of orders that failed */
+  failedCount: number
+}
+
+/**
+ * Input for inserting batch records
+ */
+export interface InsertBatchRecordInput {
+  /** Original input production ID (e.g., "22A1") */
+  productionId: string | null
+  /** Resolved order number (e.g., "SC70202602120085") */
+  orderNumber: string
+}
+
+/**
+ * Result for batch status update
+ */
+export interface UpdateBatchStatusResult {
+  /** Whether the update was successful */
+  success: boolean
+  /** Number of records updated */
+  updatedCount: number
+}
+
+/**
+ * Options for querying batches
+ */
+export interface GetBatchesOptions {
+  /** Maximum number of batches to return */
+  limit?: number
+  /** Number of batches to skip (for pagination) */
+  offset?: number
+}

src/main/types/settings.types.ts

@@ -10,7 +10,7 @@
 /**
  * User type for settings permission control
  */
-export type UserType = 'Admin' | 'User' | 'Guest'
+export type UserType = 'Admin' | 'User'
 
 /**
  * Database type selection

src/main/types/user.types.ts

@@ -5,7 +5,7 @@
 /**
  * User type enumeration
  */
-export type UserType = 'Admin' | 'User' | 'Guest'
+export type UserType = 'Admin' | 'User'
 
 /**
  * User information interface

src/preload/api/index.ts

@@ -17,6 +17,7 @@ import {
 } from './materials'
 import { loggerApi } from './logger'
 import { playwrightBrowserApi } from './browser-download'
+import { operationHistoryApi } from './operation-history'
 
 export const api = {
   process: processApi,
@@ -35,7 +36,8 @@ export const api = {
   logger: loggerApi,
   report: reportApi,
   update: updateApi,
-  playwrightBrowser: playwrightBrowserApi
+  playwrightBrowser: playwrightBrowserApi,
+  operationHistory: operationHistoryApi
 } as const
 
 export type ElectronApi = typeof api

src/preload/api/operation-history.ts

@@ -0,0 +1,30 @@
+import { IPC_CHANNELS } from '../../shared/ipc-channels'
+import { invokeIpc } from '../lib/ipc'
+import type {
+  BatchStats,
+  OperationHistoryRecord,
+  GetBatchesOptions
+} from '../../main/types/operation-history.types'
+import type { IpcResult } from '../../main/types/ipc.types'
+
+export const operationHistoryApi = {
+  /**
+   * Get list of operation batches
+   * Admin users receive all batches, regular users only their own
+   */
+  getBatches: (options?: GetBatchesOptions): Promise<IpcResult<BatchStats[]>> =>
+    invokeIpc(IPC_CHANNELS.OPERATION_HISTORY_GET_BATCHES, options),
+
+  /**
+   * Get detailed records for a specific batch
+   */
+  getBatchDetails: (batchId: string): Promise<IpcResult<OperationHistoryRecord[]>> =>
+    invokeIpc(IPC_CHANNELS.OPERATION_HISTORY_GET_BATCH_DETAILS, batchId),
+
+  /**
+   * Delete a batch
+   * Admin users can delete any batch, regular users only their own
+   */
+  deleteBatch: (batchId: string): Promise<IpcResult<{ deleted: boolean }>> =>
+    invokeIpc(IPC_CHANNELS.OPERATION_HISTORY_DELETE_BATCH, batchId)
+} as const

src/preload/index.d.ts

@@ -157,6 +157,37 @@ export interface PlaywrightBrowserAPI {
   onProgress: (callback: (data: DownloadProgress) => void) => () => void
 }
 
+export interface OperationHistoryAPI {
+  getBatches: (options?: { limit?: number; offset?: number }) => Promise<IpcResult<BatchStats[]>>
+  getBatchDetails: (batchId: string) => Promise<IpcResult<OperationHistoryRecord[]>>
+  deleteBatch: (batchId: string) => Promise<IpcResult<{ deleted: boolean }>>
+}
+
+export interface BatchStats {
+  batchId: string
+  userId: number
+  username: string
+  operationTime: string
+  status: string
+  totalOrders: number
+  totalRecords: number
+  successCount: number
+  failedCount: number
+}
+
+export interface OperationHistoryRecord {
+  id?: number
+  batchId: string
+  userId: number
+  username: string
+  productionId: string | null
+  orderNumber: string
+  operationTime: Date
+  status: string
+  recordCount: number | null
+  errorMessage: string | null
+}
+
 export interface ProcessAPI {
   versions: {
     electron: string
@@ -185,6 +216,7 @@ declare global {
       report: ReportAPI
       update: UpdateAPI
       playwrightBrowser: PlaywrightBrowserAPI
+      operationHistory: OperationHistoryAPI
     }
     api: unknown
   }

src/renderer/src/components/ExtractorOperationHistoryModal.tsx

@@ -0,0 +1,392 @@
+/**
+ * Extractor Operation History Modal
+ *
+ * Displays extraction operation history with batch statistics and details.
+ * Admin users see all users' records, regular users see only their own.
+ */
+
+import React, { useState, useEffect } from 'react'
+import { Modal } from './ui/Modal'
+import {
+  RefreshCw,
+  Trash2,
+  ChevronDown,
+  ChevronRight,
+  CheckCircle,
+  XCircle,
+  Clock
+} from 'lucide-react'
+import type { UserInfo } from './UserSelectionDialog'
+
+// Local type definitions matching the backend types
+interface BatchStats {
+  batchId: string
+  userId: number
+  username: string
+  operationTime: string
+  status: string
+  totalOrders: number
+  totalRecords: number
+  successCount: number
+  failedCount: number
+}
+
+interface OperationHistoryRecord {
+  id?: number
+  batchId: string
+  userId: number
+  username: string
+  productionId: string | null
+  orderNumber: string
+  operationTime: Date
+  status: string
+  recordCount: number | null
+  errorMessage: string | null
+}
+
+interface ExtractorOperationHistoryModalProps {
+  isOpen: boolean
+  onClose: () => void
+  user?: UserInfo | null
+}
+
+const statusStyles: Record<string, string> = {
+  success: 'bg-green-100 text-green-700',
+  partial: 'bg-amber-100 text-amber-700',
+  failed: 'bg-red-100 text-red-700',
+  pending: 'bg-gray-100 text-gray-700'
+}
+
+const statusLabels: Record<string, string> = {
+  success: '成功',
+  partial: '部分成功',
+  failed: '失败',
+  pending: '进行中'
+}
+
+const statusIcons: Record<string, React.ReactNode> = {
+  success: <CheckCircle size={16} className="text-green-600" />,
+  partial: <Clock size={16} className="text-amber-600" />,
+  failed: <XCircle size={16} className="text-red-600" />,
+  pending: <Clock size={16} className="text-gray-500" />
+}
+
+export const ExtractorOperationHistoryModal: React.FC<ExtractorOperationHistoryModalProps> = ({
+  isOpen,
+  onClose,
+  user
+}) => {
+  const [batches, setBatches] = useState<BatchStats[]>([])
+  const [loading, setLoading] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+  const [expandedBatches, setExpandedBatches] = useState<Set<string>>(new Set())
+  const [batchDetails, setBatchDetails] = useState<Map<string, OperationHistoryRecord[]>>(new Map())
+  const [deleting, setDeleting] = useState<Set<string>>(new Set())
+
+  const isAdmin = user?.userType === 'Admin'
+
+  // Fetch batches when modal opens
+  useEffect(() => {
+    if (isOpen) {
+      void fetchBatches()
+    }
+  }, [isOpen])
+
+  const fetchBatches = async () => {
+    setLoading(true)
+    setError(null)
+    try {
+      const result = await window.electron.operationHistory.getBatches({ limit: 100 })
+      if (result.success && result.data) {
+        setBatches(result.data)
+      } else {
+        setError(result.error || '获取历史记录失败')
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : '获取历史记录失败')
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  const fetchBatchDetails = async (batchId: string) => {
+    // If already loaded, don't fetch again
+    if (batchDetails.has(batchId)) {
+      return
+    }
+
+    try {
+      const result = await window.electron.operationHistory.getBatchDetails(batchId)
+      if (result.success && result.data) {
+        setBatchDetails((prev) => new Map(prev).set(batchId, result.data!))
+      }
+    } catch (err) {
+      console.error('Failed to fetch batch details:', err)
+    }
+  }
+
+  const toggleBatchExpansion = (batchId: string) => {
+    setExpandedBatches((prev) => {
+      const newSet = new Set(prev)
+      if (newSet.has(batchId)) {
+        newSet.delete(batchId)
+      } else {
+        newSet.add(batchId)
+        void fetchBatchDetails(batchId)
+      }
+      return newSet
+    })
+  }
+
+  const handleDeleteBatch = async (batchId: string) => {
+    if (deleting.has(batchId)) return
+
+    const confirmed = confirm('确定要删除此批次记录吗？此操作不可撤销。')
+    if (!confirmed) return
+
+    setDeleting((prev) => new Set(prev).add(batchId))
+
+    try {
+      const result = await window.electron.operationHistory.deleteBatch(batchId)
+      if (result.success) {
+        // Remove from local state
+        setBatches((prev) => prev.filter((b) => b.batchId !== batchId))
+        setBatchDetails((prev) => {
+          const newMap = new Map(prev)
+          newMap.delete(batchId)
+          return newMap
+        })
+        setExpandedBatches((prev) => {
+          const newSet = new Set(prev)
+          newSet.delete(batchId)
+          return newSet
+        })
+      } else {
+        alert(result.error || '删除失败')
+      }
+    } catch (err) {
+      alert(err instanceof Error ? err.message : '删除失败')
+    } finally {
+      setDeleting((prev) => {
+        const newSet = new Set(prev)
+        newSet.delete(batchId)
+        return newSet
+      })
+    }
+  }
+
+  const formatDateTime = (dateStr: string) => {
+    const date = new Date(dateStr)
+    return date.toLocaleString('zh-CN', {
+      year: 'numeric',
+      month: '2-digit',
+      day: '2-digit',
+      hour: '2-digit',
+      minute: '2-digit'
+    })
+  }
+
+  if (!isOpen) return null
+
+  return (
+    <Modal isOpen={isOpen} onClose={onClose} title="操作历史" size="3xl">
+      <div className="flex flex-col h-[70vh]">
+        {/* Toolbar */}
+        <div className="flex items-center justify-between mb-4 pb-4 border-b border-gray-200">
+          <div className="flex items-center gap-4">
+            <span className="text-sm text-gray-600">
+              {isAdmin ? (
+                <span className="text-amber-600 font-medium">管理员模式：显示所有用户记录</span>
+              ) : (
+                <span>仅显示您的操作记录</span>
+              )}
+            </span>
+            {batches.length > 0 && (
+              <span className="text-sm text-gray-500">共 {batches.length} 条批次</span>
+            )}
+          </div>
+          <button
+            className="p-2 hover:bg-gray-100 rounded-lg transition-colors disabled:opacity-50"
+            onClick={() => void fetchBatches()}
+            disabled={loading}
+            title="刷新"
+          >
+            <RefreshCw size={18} className={loading ? 'animate-spin' : ''} />
+          </button>
+        </div>
+
+        {/* Error message */}
+        {error && (
+          <div className="mb-4 p-3 bg-red-50 border border-red-200 rounded-lg text-red-700 text-sm">
+            {error}
+          </div>
+        )}
+
+        {/* Batch list */}
+        <div className="flex-1 overflow-y-auto">
+          {loading && batches.length === 0 ? (
+            <div className="flex items-center justify-center h-32 text-gray-500">加载中...</div>
+          ) : batches.length === 0 ? (
+            <div className="flex items-center justify-center h-32 text-gray-500">暂无操作记录</div>
+          ) : (
+            <div className="flex flex-col gap-3">
+              {batches.map((batch) => {
+                const isExpanded = expandedBatches.has(batch.batchId)
+                const details = batchDetails.get(batch.batchId) || []
+                const isDeleting = deleting.has(batch.batchId)
+
+                return (
+                  <div
+                    key={batch.batchId}
+                    className="border border-gray-200 rounded-lg overflow-hidden"
+                  >
+                    {/* Batch summary */}
+                    <div
+                      className={`flex items-center justify-between p-4 cursor-pointer transition-colors ${
+                        isExpanded ? 'bg-gray-50' : 'hover:bg-gray-50'
+                      }`}
+                      onClick={() => toggleBatchExpansion(batch.batchId)}
+                    >
+                      <div className="flex items-center gap-4 flex-1">
+                        <button className="p-1 hover:bg-gray-200 rounded">
+                          {isExpanded ? <ChevronDown size={18} /> : <ChevronRight size={18} />}
+                        </button>
+
+                        <div className="flex-1 grid grid-cols-6 gap-4 text-sm">
+                          <div>
+                            <div className="text-gray-500 text-xs">操作时间</div>
+                            <div className="font-medium text-gray-900">
+                              {formatDateTime(batch.operationTime)}
+                            </div>
+                          </div>
+                          <div>
+                            <div className="text-gray-500 text-xs">操作用户</div>
+                            <div className="font-medium text-gray-900">{batch.username}</div>
+                          </div>
+                          <div>
+                            <div className="text-gray-500 text-xs">状态</div>
+                            <div className="flex items-center gap-1">
+                              {statusIcons[batch.status] || statusIcons.pending}
+                              <span
+                                className={`px-2 py-0.5 rounded text-xs font-medium ${
+                                  statusStyles[batch.status] || statusStyles.pending
+                                }`}
+                              >
+                                {statusLabels[batch.status] || batch.status}
+                              </span>
+                            </div>
+                          </div>
+                          <div>
+                            <div className="text-gray-500 text-xs">订单数</div>
+                            <div className="font-medium text-gray-900">{batch.totalOrders}</div>
+                          </div>
+                          <div>
+                            <div className="text-gray-500 text-xs">记录数</div>
+                            <div className="font-medium text-gray-900">{batch.totalRecords}</div>
+                          </div>
+                          <div>
+                            <div className="text-gray-500 text-xs">成功/失败</div>
+                            <div className="font-medium text-gray-900">
+                              <span className="text-green-600">{batch.successCount}</span>
+                              {batch.failedCount > 0 && (
+                                <>
+                                  {' / '}
+                                  <span className="text-red-600">{batch.failedCount}</span>
+                                </>
+                              )}
+                            </div>
+                          </div>
+                        </div>
+                      </div>
+
+                      <button
+                        className="p-2 hover:bg-red-50 text-gray-400 hover:text-red-600 rounded transition-colors disabled:opacity-50"
+                        onClick={(e) => {
+                          e.stopPropagation()
+                          void handleDeleteBatch(batch.batchId)
+                        }}
+                        disabled={isDeleting}
+                        title="删除批次"
+                      >
+                        <Trash2 size={16} className={isDeleting ? 'animate-pulse' : ''} />
+                      </button>
+                    </div>
+
+                    {/* Batch details */}
+                    {isExpanded && details.length > 0 && (
+                      <div className="border-t border-gray-200 bg-white">
+                        <div className="overflow-x-auto">
+                          <table className="w-full text-sm">
+                            <thead className="bg-gray-50">
+                              <tr>
+                                <th className="px-4 py-2 text-left font-medium text-gray-600">
+                                  总排号
+                                </th>
+                                <th className="px-4 py-2 text-left font-medium text-gray-600">
+                                  订单号
+                                </th>
+                                <th className="px-4 py-2 text-left font-medium text-gray-600">
+                                  状态
+                                </th>
+                                <th className="px-4 py-2 text-left font-medium text-gray-600">
+                                  记录数
+                                </th>
+                                <th className="px-4 py-2 text-left font-medium text-gray-600">
+                                  错误信息
+                                </th>
+                              </tr>
+                            </thead>
+                            <tbody className="divide-y divide-gray-100">
+                              {details.map((detail) => (
+                                <tr key={detail.id} className="hover:bg-gray-50">
+                                  <td className="px-4 py-2 text-gray-900">
+                                    {detail.productionId || '-'}
+                                  </td>
+                                  <td className="px-4 py-2 text-gray-900 font-mono text-xs">
+                                    {detail.orderNumber}
+                                  </td>
+                                  <td className="px-4 py-2">
+                                    <span
+                                      className={`inline-flex items-center gap-1 px-2 py-0.5 rounded text-xs font-medium ${
+                                        statusStyles[detail.status] || statusStyles.pending
+                                      }`}
+                                    >
+                                      {statusIcons[detail.status]}
+                                      {statusLabels[detail.status] || detail.status}
+                                    </span>
+                                  </td>
+                                  <td className="px-4 py-2 text-gray-900">
+                                    {detail.recordCount ?? '-'}
+                                  </td>
+                                  <td className="px-4 py-2 text-red-600 text-xs max-w-xs truncate">
+                                    {detail.errorMessage || '-'}
+                                  </td>
+                                </tr>
+                              ))}
+                            </tbody>
+                          </table>
+                        </div>
+                      </div>
+                    )}
+                  </div>
+                )
+              })}
+            </div>
+          )}
+        </div>
+
+        {/* Footer */}
+        <div className="pt-4 border-t border-gray-200 flex justify-end">
+          <button
+            className="px-6 py-2 rounded-md bg-gray-100 hover:bg-gray-200 text-gray-700 font-medium transition-colors"
+            onClick={onClose}
+          >
+            关闭
+          </button>
+        </div>
+      </div>
+    </Modal>
+  )
+}
+
+export default ExtractorOperationHistoryModal

src/renderer/src/components/ReportAnalysisDialog.tsx

@@ -1,823 +1,35 @@
-import React, { useCallback, useEffect, useState, useMemo } from 'react'
-import { X, BarChart3, Loader2, AlertCircle } from 'lucide-react'
-import {
-  XAxis,
-  YAxis,
-  CartesianGrid,
-  Tooltip,
-  Legend,
-  ResponsiveContainer,
-  Line,
-  ComposedChart
-} from 'recharts'
-
-interface ReportAnalysisDialogProps {
-  isOpen: boolean
-  onClose: () => void
-  isAdmin: boolean
-}
-
-// Extracted metrics from a single report
-interface ReportMetrics {
-  date: string
-  user: string
-  processedOrders: number
-  deletedMaterials: number
-  skippedMaterials: number
-  errors: number
-  retriedOrders: number
-  successfulRetries: number
-  executionTimeSecs: number
-  timestamp: number
-}
-
-// Aggregated daily metrics
-interface DailyMetrics {
-  date: string
-  processedOrders: number
-  deletedMaterials: number
-  skippedMaterials: number
-  errors: number
-  retriedOrders: number
-  successfulRetries: number
-  executionTimeSecs: number
-  avgExecutionTimeSecs: number
-  users: string[] // Unique users who ran reports on this day
-  reportCount: number
-}
-
-// User-specific daily metrics for comparison view
-interface UserDailyMetrics {
-  date: string
-  user: string
-  processedOrders: number
-  deletedMaterials: number
-  skippedMaterials: number
-  errors: number
-  retriedOrders: number
-  successfulRetries: number
-  executionTimeSecs: number
-  reportCount: number
-}
-
-type MetricKey = keyof Omit<DailyMetrics, 'date' | 'users' | 'reportCount' | 'avgExecutionTimeSecs'>
-
-const METRIC_LABELS: Record<MetricKey, string> = {
-  processedOrders: '处理订单数',
-  deletedMaterials: '删除物料数',
-  skippedMaterials: '跳过物料数',
-  errors: '错误数量',
-  retriedOrders: '重试订单数',
-  successfulRetries: '成功重试数',
-  executionTimeSecs: '每订单平均耗时(秒)'
-}
-
-const METRIC_COLORS: Record<MetricKey, string> = {
-  processedOrders: '#3b82f6', // blue-500
-  deletedMaterials: '#ef4444', // red-500
-  skippedMaterials: '#eab308', // yellow-500
-  errors: '#000000', // black
-  retriedOrders: '#8b5cf6', // violet-500
-  successfulRetries: '#10b981', // emerald-500
-  executionTimeSecs: '#f97316' // orange-500
-}
-
-// User colors for comparison view
-const USER_COLORS = [
-  '#3b82f6', // blue-500
-  '#10b981', // emerald-500
-  '#f59e0b', // amber-500
-  '#ef4444', // red-500
-  '#8b5cf6', // violet-500
-  '#ec4899', // pink-500
-  '#06b6d4', // cyan-500
-  '#84cc16'  // lime-500
-]
-
-const getUserColor = (user: string, users: string[]): string => {
-  const index = users.indexOf(user)
-  return USER_COLORS[index % USER_COLORS.length]
-}
-
-export const ReportAnalysisDialog: React.FC<ReportAnalysisDialogProps> = ({
-  isOpen,
-  onClose,
-  isAdmin
-}) => {
-  const [isLoading, setIsLoading] = useState(false)
-  const [error, setError] = useState<string | null>(null)
-  const [reportData, setReportData] = useState<ReportMetrics[]>([])
-
-  // Selected metrics for the chart
-  const [selectedMetrics, setSelectedMetrics] = useState<Set<MetricKey>>(
-    new Set(['processedOrders', 'deletedMaterials', 'errors'])
-  )
-
-  // View mode: aggregated (by date) or comparison (by user)
-  const [viewMode, setViewMode] = useState<'aggregated' | 'comparison'>('aggregated')
-
-  // Selected users for comparison view
-  const [selectedUsers, setSelectedUsers] = useState<Set<string>>(new Set())
-
-  const parseDurationToSeconds = (durationStr: string): number => {
-    // Handle empty or zero case
-    if (!durationStr || durationStr === '0秒' || durationStr === '0分0秒') {
-      return 0
-    }
-
-    // Remove any remaining backticks
-    const cleanStr = durationStr.replace(/\`/g, '').trim()
-
-    let totalSeconds = 0
-    const minutesMatch = cleanStr.match(/(\d+)分/)
-    if (minutesMatch) {
-      totalSeconds += parseInt(minutesMatch[1], 10) * 60
-    }
-    const secondsMatch = cleanStr.match(/(\d+)秒/)
-    if (secondsMatch) {
-      totalSeconds += parseInt(secondsMatch[1], 10)
-    }
-
-    return totalSeconds
-  }
-
-  const loadAndAnalyzeReports = useCallback(async () => {
-    if (!isAdmin) return
-
-    setIsLoading(true)
-    setError(null)
-    try {
-      // 1. Fetch report list
-      const listResult = await window.electron.report.listAll()
-      if (!listResult.success || !listResult.data) {
-        throw new Error(listResult.error || '获取报告列表失败')
-      }
-
-      const reports = listResult.data
-      const metricsList: ReportMetrics[] = []
-
-      // 2. Fetch content for each report (in chunks to avoid memory/network issues if there are many)
-      const chunkSize = 10
-      for (let i = 0; i < reports.length; i += chunkSize) {
-        const chunk = reports.slice(i, i + chunkSize)
-        const contentPromises = chunk.map(async (report) => {
-          try {
-            const contentResult = await window.electron.report.download(report.key)
-            if (contentResult.success && contentResult.data) {
-              return { report, content: contentResult.data }
-            }
-          } catch (e) {
-            console.warn(`Failed to fetch content for report ${report.key}`, e)
-          }
-          return null
-        })
-
-        const chunkContents = await Promise.all(contentPromises)
-
-        // 3. Parse each report's markdown content
-        for (const item of chunkContents) {
-          if (!item) continue
-
-          const { report, content } = item
-
-          // Regex to extract values from the markdown table
-          const extractValue = (key: string): string | null => {
-            // Try multiple patterns in order of specificity
-            const patterns = [
-              // Pattern 1: Standard format with backticks
-              new RegExp(`\\|\\s*\\*\\*${key}\\*\\*\\s*\\|\\s*\`([^\`]+)\`\\s*\\|`),
-              // Pattern 2: Without backticks (fallback for older formats)
-              new RegExp(`\\|\\s*\\*\\*${key}\\*\\*\\s*\\|\\s*([^\\|\\s]+(?:\\s+[^\\|\\s]+)*)\\s*\\|`),
-              // Pattern 3: More relaxed - any content between pipes
-              new RegExp(`\\|\\s*\\*\\*${key}\\*\\*\\s*\\|\\s*(.+?)\\s*\\|`)
-            ]
-
-            for (const pattern of patterns) {
-              const match = content.match(pattern)
-              if (match && match[1]) {
-                const value = match[1].trim()
-                // Remove backticks if they're still present
-                return value.replace(/\`/g, '')
-              }
-            }
-
-            return null
-          }
-
-          const execTimeStr = extractValue('执行时间')
-          const user = extractValue('操作用户') || report.username || 'unknown'
-          const processedOrders = parseInt(extractValue('处理订单数') || '0', 10)
-          const deletedMaterials = parseInt(extractValue('删除物料数') || '0', 10)
-          const skippedMaterials = parseInt(extractValue('跳过物料数') || '0', 10)
-          const errors = parseInt(extractValue('错误数量') || '0', 10)
-          const retriedOrders = parseInt(extractValue('重试订单数') || '0', 10)
-          const successfulRetries = parseInt(extractValue('成功重试数') || '0', 10)
-          const executionTimeStr = extractValue('执行耗时') || '0秒'
-          if (executionTimeStr === '0秒') {
-            console.warn('Failed to extract execution time from report:', report.key)
-          }
-
-          const executionTimeSecs = parseDurationToSeconds(executionTimeStr)
-
-          // Try to parse the date
-          let dateStr = '未知日期'
-          let timestamp = report.lastModified ? new Date(report.lastModified).getTime() : 0
-
-          if (execTimeStr) {
-            try {
-              const parsedDate = new Date(execTimeStr)
-              if (!isNaN(parsedDate.getTime())) {
-                dateStr = parsedDate
-                  .toLocaleDateString('zh-CN', {
-                    year: 'numeric',
-                    month: '2-digit',
-                    day: '2-digit'
-                  })
-                  .replace(/\//g, '-')
-                timestamp = parsedDate.getTime()
-              }
-            } catch {
-              // Fallback to report lastModified
-            }
-          }
-
-          if (dateStr === '未知日期' && report.lastModified) {
-            const d = new Date(report.lastModified)
-            dateStr = d
-              .toLocaleDateString('zh-CN', {
-                year: 'numeric',
-                month: '2-digit',
-                day: '2-digit'
-              })
-              .replace(/\//g, '-')
-          }
-
-          metricsList.push({
-            date: dateStr,
-            user,
-            processedOrders,
-            deletedMaterials,
-            skippedMaterials,
-            errors,
-            retriedOrders,
-            successfulRetries,
-            executionTimeSecs,
-            timestamp
-          })
-        }
-      }
-
-      setReportData(metricsList)
-    } catch (err: any) {
-      setError(err.message || '分析报告时发生错误')
-    } finally {
-      setIsLoading(false)
-    }
-  }, [isAdmin])
-
-  useEffect(() => {
-    if (isOpen && isAdmin) {
-      void loadAndAnalyzeReports()
-    } else {
-      setReportData([])
-      setError(null)
-    }
-  }, [isOpen, isAdmin, loadAndAnalyzeReports])
-
-  // Aggregate data by date
-  const chartData = useMemo(() => {
-    if (!reportData.length) return []
-
-    const dailyMap = new Map<string, DailyMetrics>()
-
-    for (const data of reportData) {
-      const { date } = data
-
-      if (!dailyMap.has(date)) {
-        dailyMap.set(date, {
-          date,
-          processedOrders: 0,
-          deletedMaterials: 0,
-          skippedMaterials: 0,
-          errors: 0,
-          retriedOrders: 0,
-          successfulRetries: 0,
-          executionTimeSecs: 0,
-          avgExecutionTimeSecs: 0,
-          users: [],
-          reportCount: 0
-        })
-      }
-
-      const day = dailyMap.get(date)!
-      day.processedOrders += data.processedOrders
-      day.deletedMaterials += data.deletedMaterials
-      day.skippedMaterials += data.skippedMaterials
-      day.errors += data.errors
-      day.retriedOrders += data.retriedOrders
-      day.successfulRetries += data.successfulRetries
-      day.executionTimeSecs += data.executionTimeSecs
-      day.reportCount += 1
-
-      if (!day.users.includes(data.user)) {
-        day.users.push(data.user)
-      }
-    }
-
-    // Calculate average execution time per order for each day
-    // Formula: total execution time / total processed orders (efficiency metric)
-    for (const day of dailyMap.values()) {
-      day.avgExecutionTimeSecs = day.processedOrders > 0
-        ? day.executionTimeSecs / day.processedOrders
-        : 0
-      // Replace executionTimeSecs with avgExecutionTimeSecs for chart display
-      day.executionTimeSecs = day.avgExecutionTimeSecs
-    }
-
-    // Convert map to array and sort by date
-    const sortedData = Array.from(dailyMap.values()).sort((a, b) => {
-      // Basic string comparison works for YYYY-MM-DD
-      return a.date.localeCompare(b.date)
-    })
-
-    return sortedData
-  }, [reportData])
-
-  // Extract all unique users from report data
-  const allUsers = useMemo(() => {
-    const userSet = new Set<string>()
-    reportData.forEach(data => userSet.add(data.user))
-    return Array.from(userSet).sort()
-  }, [reportData])
-
-  // Aggregate data by date AND user for comparison view
-  const comparisonData = useMemo(() => {
-    if (!reportData.length) return []
-
-    // Filter by selected users if any
-    const filteredData = selectedUsers.size > 0
-      ? reportData.filter(data => selectedUsers.has(data.user))
-      : reportData
-
-    // Group by date + user
-    const keyMap = new Map<string, UserDailyMetrics>()
-
-    for (const data of filteredData) {
-      const key = `${data.date}|${data.user}`
-
-      if (!keyMap.has(key)) {
-        keyMap.set(key, {
-          date: data.date,
-          user: data.user,
-          processedOrders: 0,
-          deletedMaterials: 0,
-          skippedMaterials: 0,
-          errors: 0,
-          retriedOrders: 0,
-          successfulRetries: 0,
-          executionTimeSecs: 0,
-          reportCount: 0
-        })
-      }
-
-      const entry = keyMap.get(key)!
-      entry.processedOrders += data.processedOrders
-      entry.deletedMaterials += data.deletedMaterials
-      entry.skippedMaterials += data.skippedMaterials
-      entry.errors += data.errors
-      entry.retriedOrders += data.retriedOrders
-      entry.successfulRetries += data.successfulRetries
-      entry.executionTimeSecs += data.executionTimeSecs
-      entry.reportCount += 1
-    }
-
-    // Calculate average execution time per order for each entry
-    // Formula: total execution time / total processed orders (efficiency metric)
-    for (const entry of keyMap.values()) {
-      entry.executionTimeSecs = entry.processedOrders > 0
-        ? entry.executionTimeSecs / entry.processedOrders
-        : 0
-    }
-
-    return Array.from(keyMap.values())
-      .sort((a, b) => {
-        const dateCompare = a.date.localeCompare(b.date)
-        if (dateCompare !== 0) return dateCompare
-        return a.user.localeCompare(b.user)
-      })
-  }, [reportData, selectedUsers])
-
-  // Format comparison data for chart rendering
-  const comparisonChartData = useMemo(() => {
-    if (!comparisonData.length) return []
-
-    const dates = [...new Set(comparisonData.map(d => d.date))].sort()
-    const users = [...new Set(comparisonData.map(d => d.user))]
-      .filter(user => selectedUsers.size === 0 || selectedUsers.has(user))
-      .sort()
-
-    const lookup = new Map<string, UserDailyMetrics>()
-    comparisonData.forEach(d => {
-      lookup.set(`${d.date}|${d.user}`, d)
-    })
-
-    return dates.map(date => {
-      const point: any = { date }
-      users.forEach(user => {
-        const key = `${date}|${user}`
-        const data = lookup.get(key)
-
-        Array.from(selectedMetrics).forEach(metric => {
-          const userKey = `${user}_${metric}` as any
-          point[userKey] = data ? (data as any)[metric] : 0
-        })
-      })
-      return point
-    })
-  }, [comparisonData, selectedMetrics, selectedUsers])
-
-  const handleMetricToggle = (metric: MetricKey) => {
-    // In comparison view, only allow single metric selection
-    if (viewMode === 'comparison') {
-      setSelectedMetrics(new Set([metric]))
-    } else {
-      // In aggregated view, allow multiple metric selection
-      const next = new Set(selectedMetrics)
-      if (next.has(metric)) {
-        if (next.size > 1) {
-          // Ensure at least one metric is selected
-          next.delete(metric)
-        }
-      } else {
-        next.add(metric)
-      }
-      setSelectedMetrics(next)
-    }
-  }
-
-  const handleViewModeChange = (newMode: 'aggregated' | 'comparison') => {
-    setViewMode(newMode)
-    // When switching to comparison view, keep only the first selected metric
-    if (newMode === 'comparison' && selectedMetrics.size > 1) {
-      const firstMetric = Array.from(selectedMetrics)[0]
-      setSelectedMetrics(new Set([firstMetric]))
-    }
-  }
-
-  // Custom Tooltip formatter
-  const CustomTooltip = ({ active, payload, label }: any) => {
-    if (active && payload && payload.length) {
-      // Find the original daily data
-      const dailyData = chartData.find((d) => d.date === label)
-
-      return (
-        <div className="bg-white p-4 border border-slate-200 shadow-lg rounded-lg max-w-sm">
-          <p className="font-semibold text-slate-800 mb-2 border-b border-slate-100 pb-2">
-            {label}
-          </p>
-
-          <div className="space-y-1.5 text-sm">
-            {payload.map((entry: any, index: number) => (
-              <div key={index} className="flex justify-between items-center gap-4">
-                <span className="flex items-center gap-1.5 text-slate-600">
-                  <span
-                    className="w-2.5 h-2.5 rounded-full"
-                    style={{ backgroundColor: entry.color }}
-                  ></span>
-                  {entry.name}:
-                </span>
-                <span className="font-medium text-slate-900">
-                  {entry.value} {entry.dataKey === 'executionTimeSecs' ? '秒' : ''}
-                </span>
-              </div>
-            ))}
-          </div>
-
-          {dailyData && (
-            <div className="mt-3 pt-2 border-t border-slate-100 text-xs text-slate-500">
-              <p>操作用户: {dailyData.users.join(', ')}</p>
-              <p className="mt-1">报告总数: {dailyData.reportCount}</p>
-              <p className="mt-1">每订单平均耗时: {dailyData.avgExecutionTimeSecs.toFixed(1)} 秒</p>
-            </div>
-          )}
-        </div>
-      )
-    }
-    return null
-  }
-
-  // Comparison Tooltip for user-specific data
-  const ComparisonTooltip = ({ active, payload, label, users, selectedUsers }: any) => {
-    if (active && payload && payload.length) {
-      const displayUsers = selectedUsers.size === 0 ? users : Array.from(selectedUsers)
-      const firstMetric = Array.from(selectedMetrics)[0]
-
-      return (
-        <div className="bg-white p-4 border border-slate-200 shadow-lg rounded-lg max-w-sm">
-          <p className="font-semibold text-slate-800 mb-2 border-b border-slate-100 pb-2">{label}</p>
-
-          <div className="space-y-1.5 text-sm">
-            {displayUsers.map((user: string) => {
-              const userEntry = payload.find((p: any) => p.name === (user || '未分配'))
-              if (!userEntry) return null
-
-              return (
-                <div key={user} className="flex justify-between items-center gap-4">
-                  <span className="flex items-center gap-1.5 text-slate-600">
-                    <span className="w-2.5 h-2.5 rounded-full" style={{ backgroundColor: userEntry.color }} />
-                    {user || '未分配'}:
-                  </span>
-                  <span className="font-medium text-slate-900">
-                    {userEntry.value} {firstMetric === 'executionTimeSecs' ? '秒' : ''}
-                  </span>
-                </div>
-              )
-            })}
-          </div>
-        </div>
-      )
-    }
-    return null
-  }
-
-  if (!isOpen) return null
-  if (!isAdmin) return null
-
-  return (
-    <div className="fixed inset-0 z-[110] flex items-center justify-center bg-slate-900/50 backdrop-blur-sm animate-in fade-in duration-200">
-      <div className="bg-white rounded-2xl shadow-2xl w-[1000px] max-w-[95vw] h-[85vh] flex flex-col border border-slate-200 overflow-hidden animate-in zoom-in-95 duration-200">
-        {/* Header */}
-        <div className="flex items-center justify-between px-6 py-4 border-b border-slate-200 bg-slate-50 flex-shrink-0">
-          <div className="flex items-center gap-2 text-slate-800">
-            <BarChart3 size={20} className="text-blue-600" />
-            <h2 className="text-lg font-semibold">执行报告分析</h2>
-          </div>
-          <button
-            onClick={onClose}
-            className="text-slate-400 hover:text-slate-600 hover:bg-slate-200/50 p-1.5 rounded-lg transition-colors"
-          >
-            <X size={20} />
-          </button>
-        </div>
-
-        {/* Content */}
-        <div className="flex-1 overflow-hidden flex flex-col bg-white">
-          {isLoading ? (
-            <div className="flex-1 flex flex-col items-center justify-center text-slate-500">
-              <Loader2 size={32} className="animate-spin text-blue-500 mb-4" />
-              <p>正在分析报告数据，可能需要几秒钟...</p>
-            </div>
-          ) : error ? (
-            <div className="flex-1 flex flex-col items-center justify-center text-red-500 p-8 text-center">
-              <AlertCircle size={48} className="mb-4 opacity-80" />
-              <p className="text-lg font-medium mb-2">分析失败</p>
-              <p className="text-sm opacity-80">{error}</p>
-              <button
-                onClick={loadAndAnalyzeReports}
-                className="mt-6 px-4 py-2 bg-red-50 text-red-600 border border-red-200 rounded-lg hover:bg-red-100 transition-colors"
-              >
-                重试
-              </button>
-            </div>
-          ) : chartData.length === 0 ? (
-            <div className="flex-1 flex flex-col items-center justify-center text-slate-400">
-              <BarChart3 size={48} className="mb-4 opacity-50 text-slate-300" />
-              <p>暂无报告数据可供分析</p>
-            </div>
-          ) : (
-            <div className="flex-1 flex flex-col p-6 overflow-y-auto">
-              {/* Controls */}
-              <div className="mb-8">
-                <h3 className="text-sm font-medium text-slate-700 mb-3">
-                  选择呈现内容 ({viewMode === 'comparison' ? '单选' : '多选'})
-                </h3>
-                <div className="flex flex-wrap gap-2">
-                  {(Object.keys(METRIC_LABELS) as MetricKey[]).map((key) => {
-                    const isSelected = selectedMetrics.has(key)
-                    return (
-                      <button
-                        key={key}
-                        onClick={() => handleMetricToggle(key)}
-                        className={`
-                          px-3 py-1.5 rounded-full text-xs font-medium border transition-colors flex items-center gap-1.5
-                          ${
-                            isSelected
-                              ? 'bg-blue-50 border-blue-200 text-blue-700'
-                              : 'bg-white border-slate-200 text-slate-600 hover:bg-slate-50'
-                          }
-                        `}
-                      >
-                        <div
-                          className="w-2 h-2 rounded-full"
-                          style={{ backgroundColor: isSelected ? METRIC_COLORS[key] : '#cbd5e1' }}
-                        />
-                        {METRIC_LABELS[key]}
-                      </button>
-                    )
-                  })}
-                </div>
-              </div>
-
-              {/* View Mode Toggle */}
-              <div className="mb-6">
-                <h3 className="text-sm font-medium text-slate-700 mb-3">视图模式</h3>
-                <div className="flex gap-2">
-                  <button
-                    onClick={() => handleViewModeChange('aggregated')}
-                    className={`px-4 py-2 rounded-lg text-sm font-medium border transition-colors ${
-                      viewMode === 'aggregated'
-                        ? 'bg-blue-50 border-blue-200 text-blue-700'
-                        : 'bg-white border-slate-200 text-slate-600 hover:bg-slate-50'
-                    }`}
-                  >
-                    按日期聚合
-                  </button>
-                  <button
-                    onClick={() => handleViewModeChange('comparison')}
-                    className={`px-4 py-2 rounded-lg text-sm font-medium border transition-colors ${
-                      viewMode === 'comparison'
-                        ? 'bg-blue-50 border-blue-200 text-blue-700'
-                        : 'bg-white border-slate-200 text-slate-600 hover:bg-slate-50'
-                    }`}
-                  >
-                    用户对比
-                  </button>
-                </div>
-              </div>
-
-              {/* User Filter Chips - Only in comparison mode */}
-              {viewMode === 'comparison' && (
-                <div className="mb-6">
-                  <div className="flex items-center justify-between mb-3">
-                    <h3 className="text-sm font-medium text-slate-700">筛选用户</h3>
-                    <div className="flex gap-2">
-                      <button
-                        onClick={() => setSelectedUsers(new Set(allUsers))}
-                        className="text-xs text-blue-600 hover:underline"
-                      >
-                        全选
-                      </button>
-                      <button
-                        onClick={() => setSelectedUsers(new Set())}
-                        className="text-xs text-slate-500 hover:underline"
-                      >
-                        清空
-                      </button>
-                    </div>
-                  </div>
-
-                  <div className="flex flex-wrap gap-2">
-                    {allUsers.map((user) => {
-                      const isSelected = selectedUsers.has(user)
-                      const color = getUserColor(user, allUsers)
-
-                      return (
-                        <button
-                          key={user}
-                          onClick={() => {
-                            const next = new Set(selectedUsers)
-                            if (next.has(user)) {
-                              next.delete(user)
-                            } else {
-                              next.add(user)
-                            }
-                            setSelectedUsers(next)
-                          }}
-                          className={`px-3 py-1.5 rounded-full text-xs font-medium border transition-colors flex items-center gap-1.5 ${
-                            isSelected
-                              ? 'bg-white border-current'
-                              : 'bg-white border-slate-200 text-slate-600 hover:bg-slate-50'
-                          }`}
-                          style={isSelected ? { color, borderColor: color } : {}}
-                        >
-                          <div
-                            className="w-2 h-2 rounded-full"
-                            style={{ backgroundColor: isSelected ? color : '#cbd5e1' }}
-                          />
-                          {user || '未分配'}
-                        </button>
-                      )
-                    })}
-                  </div>
-
-                  {selectedUsers.size === 0 && (
-                    <p className="text-xs text-slate-500 mt-2">
-                      未选择用户时将显示所有用户数据
-                    </p>
-                  )}
-                </div>
-              )}
-
-              {/* Chart */}
-              <div className="flex-1 min-h-[400px]">
-                {viewMode === 'aggregated' ? (
-                  <ResponsiveContainer width="100%" height="100%">
-                    <ComposedChart
-                      data={chartData}
-                      margin={{ top: 20, right: 30, left: 20, bottom: 20 }}
-                    >
-                      <CartesianGrid strokeDasharray="3 3" vertical={false} stroke="#e2e8f0" />
-                      <XAxis
-                        dataKey="date"
-                        axisLine={false}
-                        tickLine={false}
-                        tick={{ fill: '#64748b', fontSize: 12 }}
-                        dy={10}
-                      />
-                      <YAxis
-                        axisLine={false}
-                        tickLine={false}
-                        tick={{ fill: '#64748b', fontSize: 12 }}
-                      />
-                      <Tooltip content={<CustomTooltip />} />
-                      <Legend wrapperStyle={{ paddingTop: '20px' }} iconType="circle" />
-
-                      {Array.from(selectedMetrics).map((metric) => (
-                        <Line
-                          key={metric}
-                          type="monotone"
-                          dataKey={metric}
-                          name={METRIC_LABELS[metric]}
-                          stroke={METRIC_COLORS[metric]}
-                          strokeWidth={2}
-                          dot={{ r: 4, strokeWidth: 2 }}
-                          activeDot={{ r: 6, strokeWidth: 0 }}
-                        />
-                      ))}
-                    </ComposedChart>
-                  </ResponsiveContainer>
-                ) : (
-                  <ResponsiveContainer width="100%" height="100%">
-                    <ComposedChart
-                      data={comparisonChartData}
-                      margin={{ top: 20, right: 30, left: 20, bottom: 20 }}
-                    >
-                      <CartesianGrid strokeDasharray="3 3" vertical={false} stroke="#e2e8f0" />
-                      <XAxis
-                        dataKey="date"
-                        axisLine={false}
-                        tickLine={false}
-                        tick={{ fill: '#64748b', fontSize: 12 }}
-                        dy={10}
-                      />
-                      <YAxis
-                        axisLine={false}
-                        tickLine={false}
-                        tick={{ fill: '#64748b', fontSize: 12 }}
-                      />
-                      <Tooltip content={<ComparisonTooltip users={allUsers} selectedUsers={selectedUsers} />} />
-                      <Legend wrapperStyle={{ paddingTop: '20px' }} iconType="circle" />
-
-                      {selectedUsers.size === 0 || selectedUsers.size > 1
-                        ? // Multiple users: show first metric for each user
-                          allUsers.filter(user => selectedUsers.size === 0 || selectedUsers.has(user)).map((user) => (
-                            <Line
-                              key={user}
-                              type="monotone"
-                              dataKey={`${user}_${Array.from(selectedMetrics)[0]}`}
-                              name={user || '未分配'}
-                              stroke={getUserColor(user, allUsers)}
-                              strokeWidth={2}
-                              dot={{ r: 4, strokeWidth: 2 }}
-                              activeDot={{ r: 6, strokeWidth: 0 }}
-                            />
-                          ))
-                        : // Single user: show all metrics for that user
-                          Array.from(selectedMetrics).map((metric) => {
-                            const user = Array.from(selectedUsers)[0]
-                            return (
-                              <Line
-                                key={metric}
-                                type="monotone"
-                                dataKey={`${user}_${metric}`}
-                                name={METRIC_LABELS[metric]}
-                                stroke={METRIC_COLORS[metric]}
-                                strokeWidth={2}
-                                dot={{ r: 4, strokeWidth: 2 }}
-                                activeDot={{ r: 6, strokeWidth: 0 }}
-                              />
-                            )
-                          })
-                      }
-                    </ComposedChart>
-                  </ResponsiveContainer>
-                )}
-              </div>
-
-              <div className="mt-4 text-center text-xs text-slate-400">
-                {viewMode === 'aggregated'
-                  ? '数据以天为单位进行聚合统计。展示的是选定时间段内的总量。'
-                  : selectedUsers.size === 0
-                    ? '展示所有用户的数据对比。未选择用户时显示全部。'
-                    : '展示选定用户的数据对比。'
-                }
-              </div>
-            </div>
-          )}
-        </div>
-      </div>
-    </div>
-  )
-}
-
-export default ReportAnalysisDialog
+/**
+ * ReportAnalysisDialog Component - Re-export
+ *
+ * This file now re-exports the refactored component from the report-analysis module.
+ * All functionality has been preserved while improving code organization.
+ *
+ * The refactored version is located at: ./report-analysis/index.tsx
+ *
+ * Refactoring changes:
+ * - Split into 11 focused files (was 948 lines, now ~150 lines per file)
+ * - Extracted custom hooks for business logic
+ * - Separated UI components for better reusability
+ * - Centralized type definitions
+ * - Isolated utility functions for easier testing
+ *
+ * @see ./report-analysis/ for the refactored implementation
+ */
+
+// Re-export everything from the refactored module
+export { ReportAnalysisDialog as default, ReportAnalysisDialog } from './report-analysis'
+
+// Re-export types for external use
+export type {
+  ReportMetrics,
+  DailyMetrics,
+  UserDailyMetrics,
+  MetricKey,
+  ViewMode,
+  ReportAnalysisDialogProps,
+  CustomTooltipProps,
+  ComparisonTooltipProps
+} from './report-analysis/types'
+
+// Re-export constants
+export { METRIC_LABELS, METRIC_COLORS, USER_COLORS } from './report-analysis/types'

src/renderer/src/components/UserSelectionDialog.tsx

@@ -13,7 +13,7 @@ import { Modal } from './ui/Modal'
 export interface UserInfo {
   id: number
   username: string
-  userType: 'Admin' | 'User' | 'Guest'
+  userType: 'Admin' | 'User'
   createTime?: Date
 }
 
@@ -61,8 +61,7 @@ export const UserSelectionDialog: React.FC<UserSelectionDialogProps> = ({
 
   const userTypeStyles: Record<string, string> = {
     Admin: 'bg-amber-50 text-amber-600',
-    User: 'bg-blue-50 text-blue-600',
-    Guest: 'bg-gray-100 text-gray-600'
+    User: 'bg-blue-50 text-blue-600'
   }
 
   if (!isOpen) return null

src/renderer/src/components/app/UnauthenticatedApp.tsx

@@ -4,7 +4,7 @@ import UserSelectionDialog, { type UserInfo as SelectedUserInfo } from '../UserS
 
 interface CurrentUser {
   username: string
-  userType: 'Admin' | 'User' | 'Guest'
+  userType: 'Admin' | 'User'
 }
 
 interface UnauthenticatedAppProps {

src/renderer/src/components/report-analysis/components/ComparisonTooltip.tsx

@@ -0,0 +1,70 @@
+/**
+ * ComparisonTooltip Component
+ * Custom tooltip for comparison chart view showing user-specific metrics
+ */
+
+import React from 'react'
+import { MetricKey } from '../types'
+
+interface ComparisonTooltipProps {
+  active?: boolean
+  payload?: any[]
+  label?: string
+  users: string[]
+  selectedUsers: Set<string>
+  selectedMetrics: Set<MetricKey>
+}
+
+/**
+ * Renders a detailed tooltip for the comparison chart view
+ * Shows user-specific metric values for the selected date
+ */
+export const ComparisonTooltip = React.memo(
+  ({ active, payload, label, users, selectedUsers, selectedMetrics }: ComparisonTooltipProps) => {
+    if (!active || !payload || !payload.length) {
+      return null
+    }
+
+    const displayUsers = selectedUsers.size === 0 ? users : Array.from(selectedUsers)
+    const firstMetric = Array.from(selectedMetrics)[0]
+
+    return (
+      <div className="bg-white p-4 border border-slate-200 shadow-lg rounded-lg max-w-sm">
+        <p className="font-semibold text-slate-800 mb-2 border-b border-slate-100 pb-2">{label}</p>
+
+        <div className="space-y-1.5 text-sm">
+          {displayUsers.map((user: string) => {
+            const userEntry = payload.find((p: any) => p.name === (user || '未分配'))
+            if (!userEntry) return null
+
+            return (
+              <div key={user} className="flex justify-between items-center gap-4">
+                <span className="flex items-center gap-1.5 text-slate-600">
+                  <span
+                    className="w-2.5 h-2.5 rounded-full"
+                    style={{ backgroundColor: userEntry.color }}
+                  />
+                  {user || '未分配'}:
+                </span>
+                <span className="font-medium text-slate-900">
+                  {firstMetric === 'executionTimeSecs' ? Number(userEntry.value).toFixed(1) : userEntry.value} {firstMetric === 'executionTimeSecs' ? '秒' : ''}
+                </span>
+              </div>
+            )
+          })}
+        </div>
+      </div>
+    )
+  },
+  (prevProps, nextProps) => {
+    // Custom comparison for memoization
+    return (
+      prevProps.label === nextProps.label &&
+      prevProps.selectedUsers.size === nextProps.selectedUsers.size &&
+      prevProps.selectedMetrics.size === nextProps.selectedMetrics.size &&
+      prevProps.payload?.length === nextProps.payload?.length
+    )
+  }
+)
+
+ComparisonTooltip.displayName = 'ComparisonTooltip'

src/renderer/src/components/report-analysis/components/CustomTooltip.tsx

@@ -0,0 +1,68 @@
+/**
+ * CustomTooltip Component
+ * Custom tooltip for aggregated chart view showing daily metrics
+ */
+
+import React from 'react'
+import { DailyMetrics } from '../types'
+
+interface CustomTooltipProps {
+  active?: boolean
+  payload?: any[]
+  label?: string
+  chartData: DailyMetrics[]
+}
+
+/**
+ * Renders a detailed tooltip for the aggregated chart view
+ * Shows metric values along with additional context like user count and report count
+ */
+export const CustomTooltip = React.memo(
+  ({ active, payload, label, chartData }: CustomTooltipProps) => {
+    if (!active || !payload || !payload.length) {
+      return null
+    }
+
+    const dailyData = chartData.find((d) => d.date === label)
+
+    return (
+      <div className="bg-white p-4 border border-slate-200 shadow-lg rounded-lg max-w-sm">
+        <p className="font-semibold text-slate-800 mb-2 border-b border-slate-100 pb-2">{label}</p>
+
+        <div className="space-y-1.5 text-sm">
+          {payload.map((entry: any, index: number) => (
+            <div key={`${entry.name}-${index}`} className="flex justify-between items-center gap-4">
+              <span className="flex items-center gap-1.5 text-slate-600">
+                <span
+                  className="w-2.5 h-2.5 rounded-full"
+                  style={{ backgroundColor: entry.color }}
+                ></span>
+                {entry.name}:
+              </span>
+              <span className="font-medium text-slate-900">
+                {entry.dataKey === 'executionTimeSecs' ? Number(entry.value).toFixed(1) : entry.value} {entry.dataKey === 'executionTimeSecs' ? '秒' : ''}
+              </span>
+            </div>
+          ))}
+        </div>
+
+        {dailyData && (
+          <div className="mt-3 pt-2 border-t border-slate-100 text-xs text-slate-500">
+            <p>操作用户: {dailyData.users.join(', ')}</p>
+            <p className="mt-1">报告总数: {dailyData.reportCount}</p>
+          </div>
+        )}
+      </div>
+    )
+  },
+  (prevProps, nextProps) => {
+    // Custom comparison for memoization
+    return (
+      prevProps.label === nextProps.label &&
+      prevProps.payload?.length === nextProps.payload?.length &&
+      prevProps.chartData === nextProps.chartData
+    )
+  }
+)
+
+CustomTooltip.displayName = 'CustomTooltip'

src/renderer/src/components/report-analysis/components/MetricSelector.tsx

@@ -0,0 +1,54 @@
+/**
+ * MetricSelector Component
+ * Allows users to select which metrics to display in the chart
+ * Supports both single-select (comparison mode) and multi-select (aggregated mode)
+ */
+
+import React from 'react'
+import { MetricKey, METRIC_LABELS, METRIC_COLORS } from '../types'
+
+interface MetricSelectorProps {
+  selectedMetrics: Set<MetricKey>
+  viewMode: 'aggregated' | 'comparison'
+  onMetricToggle: (metric: MetricKey) => void
+}
+
+/**
+ * Renders a list of metric selection buttons
+ * Shows multi-select hint in aggregated mode and single-select hint in comparison mode
+ */
+export const MetricSelector: React.FC<MetricSelectorProps> = ({
+  selectedMetrics,
+  viewMode,
+  onMetricToggle
+}) => {
+  return (
+    <div className="mb-8">
+      <h3 className="text-sm font-medium text-slate-700 mb-3">
+        选择呈现内容 ({viewMode === 'comparison' ? '单选' : '多选'})
+      </h3>
+      <div className="flex flex-wrap gap-2">
+        {(Object.keys(METRIC_LABELS) as MetricKey[]).map((key) => {
+          const isSelected = selectedMetrics.has(key)
+          return (
+            <button
+              key={key}
+              onClick={() => onMetricToggle(key)}
+              className={`px-3 py-1.5 rounded-full text-xs font-medium border transition-colors flex items-center gap-1.5 ${
+                isSelected
+                  ? 'bg-blue-50 border-blue-200 text-blue-700'
+                  : 'bg-white border-slate-200 text-slate-600 hover:bg-slate-50'
+              }`}
+            >
+              <div
+                className="w-2 h-2 rounded-full"
+                style={{ backgroundColor: isSelected ? METRIC_COLORS[key] : '#cbd5e1' }}
+              />
+              {METRIC_LABELS[key]}
+            </button>
+          )
+        })}
+      </div>
+    </div>
+  )
+}

src/renderer/src/components/report-analysis/components/ReportChart.tsx

@@ -0,0 +1,148 @@
+/**
+ * ReportChart Component
+ * Renders the main chart display with support for both aggregated and comparison views
+ * Uses Recharts library for responsive, interactive charts
+ */
+
+import React from 'react'
+import {
+  XAxis,
+  YAxis,
+  CartesianGrid,
+  Tooltip,
+  Legend,
+  ResponsiveContainer,
+  Line,
+  ComposedChart
+} from 'recharts'
+import { DailyMetrics, MetricKey, METRIC_LABELS, METRIC_COLORS, USER_COLORS } from '../types'
+import { CustomTooltip } from './CustomTooltip'
+import { ComparisonTooltip } from './ComparisonTooltip'
+
+interface ReportChartProps {
+  viewMode: 'aggregated' | 'comparison'
+  selectedMetrics: Set<MetricKey>
+  selectedUsers: Set<string>
+  allUsers: string[]
+  chartData: DailyMetrics[]
+  comparisonChartData: any[]
+}
+
+/**
+ * Helper function to get consistent color for a user
+ */
+const getUserColor = (user: string, users: string[]): string => {
+  const index = users.indexOf(user)
+  return USER_COLORS[index % USER_COLORS.length]
+}
+
+/**
+ * Renders the appropriate chart based on view mode
+ * - Aggregated: Shows metrics grouped by date
+ * - Comparison: Shows metrics grouped by user for comparison
+ */
+export const ReportChart: React.FC<ReportChartProps> = ({
+  viewMode,
+  selectedMetrics,
+  selectedUsers,
+  allUsers,
+  chartData,
+  comparisonChartData
+}) => {
+  return (
+    <div className="flex-1 min-h-[400px]">
+      {viewMode === 'aggregated' ? (
+        // Aggregated view: metrics by date
+        <ResponsiveContainer width="100%" height="100%">
+          <ComposedChart data={chartData} margin={{ top: 20, right: 30, left: 20, bottom: 20 }}>
+            <CartesianGrid strokeDasharray="3 3" vertical={false} stroke="#e2e8f0" />
+            <XAxis
+              dataKey="date"
+              axisLine={false}
+              tickLine={false}
+              tick={{ fill: '#64748b', fontSize: 12 }}
+              dy={10}
+            />
+            <YAxis axisLine={false} tickLine={false} tick={{ fill: '#64748b', fontSize: 12 }} />
+            <Tooltip content={<CustomTooltip chartData={chartData} />} />
+            <Legend wrapperStyle={{ paddingTop: '20px' }} iconType="circle" />
+
+            {Array.from(selectedMetrics).map((metric) => (
+              <Line
+                key={metric}
+                type="monotone"
+                dataKey={metric}
+                name={METRIC_LABELS[metric]}
+                stroke={METRIC_COLORS[metric]}
+                strokeWidth={2}
+                dot={{ r: 4, strokeWidth: 2 }}
+                activeDot={{ r: 6, strokeWidth: 0 }}
+              />
+            ))}
+          </ComposedChart>
+        </ResponsiveContainer>
+      ) : (
+        // Comparison view: metrics by user
+        <ResponsiveContainer width="100%" height="100%">
+          <ComposedChart
+            data={comparisonChartData}
+            margin={{ top: 20, right: 30, left: 20, bottom: 20 }}
+          >
+            <CartesianGrid strokeDasharray="3 3" vertical={false} stroke="#e2e8f0" />
+            <XAxis
+              dataKey="date"
+              axisLine={false}
+              tickLine={false}
+              tick={{ fill: '#64748b', fontSize: 12 }}
+              dy={10}
+            />
+            <YAxis axisLine={false} tickLine={false} tick={{ fill: '#64748b', fontSize: 12 }} />
+            <Tooltip
+              content={
+                <ComparisonTooltip
+                  users={allUsers}
+                  selectedUsers={selectedUsers}
+                  selectedMetrics={selectedMetrics}
+                />
+              }
+            />
+            <Legend wrapperStyle={{ paddingTop: '20px' }} iconType="circle" />
+
+            {selectedUsers.size === 0 || selectedUsers.size > 1
+              ? // Multiple users: show first metric for each user
+                allUsers
+                  .filter((user) => selectedUsers.size === 0 || selectedUsers.has(user))
+                  .map((user) => (
+                    <Line
+                      key={user}
+                      type="monotone"
+                      dataKey={`${user}_${Array.from(selectedMetrics)[0]}`}
+                      name={user || '未分配'}
+                      stroke={getUserColor(user, allUsers)}
+                      strokeWidth={2}
+                      dot={{ r: 4, strokeWidth: 2 }}
+                      activeDot={{ r: 6, strokeWidth: 0 }}
+                    />
+                  ))
+              : // Single user: show all metrics for that user
+                Array.from(selectedMetrics).map((metric) => {
+                  const user = Array.from(selectedUsers)[0]
+                  return (
+                    <Line
+                      key={metric}
+                      type="monotone"
+                      dataKey={`${user}_${metric}`}
+                      name={METRIC_LABELS[metric]}
+                      stroke={METRIC_COLORS[metric]}
+                      strokeWidth={2}
+                      dot={{ r: 4, strokeWidth: 2 }}
+                      activeDot={{ r: 6, strokeWidth: 0 }}
+                    />
+                  )
+                })}
+          </ComposedChart>
+        </ResponsiveContainer>
+      )}
+    </div>
+  )
+}

src/renderer/src/components/report-analysis/components/UserFilter.tsx

@@ -0,0 +1,82 @@
+/**
+ * UserFilter Component
+ * Allows users to filter which users to display in comparison view
+ * Shows all users as selectable chips with color coding
+ */
+
+import React from 'react'
+import { USER_COLORS } from '../types'
+
+interface UserFilterProps {
+  allUsers: string[]
+  selectedUsers: Set<string>
+  onUserToggle: (user: string) => void
+  onSelectAll: () => void
+  onClearAll: () => void
+}
+
+/**
+ * Helper function to get consistent color for a user
+ */
+const getUserColor = (user: string, users: string[]): string => {
+  const index = users.indexOf(user)
+  return USER_COLORS[index % USER_COLORS.length]
+}
+
+/**
+ * Renders user filter interface with selectable user chips
+ * Only displayed in comparison view mode
+ */
+export const UserFilter: React.FC<UserFilterProps> = ({
+  allUsers,
+  selectedUsers,
+  onUserToggle,
+  onSelectAll,
+  onClearAll
+}) => {
+  return (
+    <div className="mb-6">
+      <div className="flex items-center justify-between mb-3">
+        <h3 className="text-sm font-medium text-slate-700">筛选用户</h3>
+        <div className="flex gap-2">
+          <button onClick={onSelectAll} className="text-xs text-blue-600 hover:underline">
+            全选
+          </button>
+          <button onClick={onClearAll} className="text-xs text-slate-500 hover:underline">
+            清空
+          </button>
+        </div>
+      </div>
+
+      <div className="flex flex-wrap gap-2">
+        {allUsers.map((user) => {
+          const isSelected = selectedUsers.has(user)
+          const color = getUserColor(user, allUsers)
+
+          return (
+            <button
+              key={user}
+              onClick={() => onUserToggle(user)}
+              className={`px-3 py-1.5 rounded-full text-xs font-medium border transition-colors flex items-center gap-1.5 ${
+                isSelected
+                  ? 'bg-white border-current'
+                  : 'bg-white border-slate-200 text-slate-600 hover:bg-slate-50'
+              }`}
+              style={isSelected ? { color, borderColor: color } : {}}
+            >
+              <div
+                className="w-2 h-2 rounded-full"
+                style={{ backgroundColor: isSelected ? color : '#cbd5e1' }}
+              />
+              {user || '未分配'}
+            </button>
+          )
+        })}
+      </div>
+
+      {selectedUsers.size === 0 && (
+        <p className="text-xs text-slate-500 mt-2">未选择用户时将显示所有用户数据</p>
+      )}
+    </div>
+  )
+}

src/renderer/src/components/report-analysis/components/ViewModeToggle.tsx

@@ -0,0 +1,47 @@
+/**
+ * ViewModeToggle Component
+ * Allows users to switch between aggregated and comparison view modes
+ */
+
+import React from 'react'
+import { ViewMode } from '../types'
+
+interface ViewModeToggleProps {
+  viewMode: ViewMode
+  onViewModeChange: (newMode: ViewMode) => void
+}
+
+/**
+ * Renders toggle buttons for switching between view modes
+ * Aggregated: shows data grouped by date
+ * Comparison: shows data grouped by user for comparison
+ */
+export const ViewModeToggle: React.FC<ViewModeToggleProps> = ({ viewMode, onViewModeChange }) => {
+  return (
+    <div className="mb-6">
+      <h3 className="text-sm font-medium text-slate-700 mb-3">视图模式</h3>
+      <div className="flex gap-2">
+        <button
+          onClick={() => onViewModeChange('aggregated')}
+          className={`px-4 py-2 rounded-lg text-sm font-medium border transition-colors ${
+            viewMode === 'aggregated'
+              ? 'bg-blue-50 border-blue-200 text-blue-700'
+              : 'bg-white border-slate-200 text-slate-600 hover:bg-slate-50'
+          }`}
+        >
+          按日期聚合
+        </button>
+        <button
+          onClick={() => onViewModeChange('comparison')}
+          className={`px-4 py-2 rounded-lg text-sm font-medium border transition-colors ${
+            viewMode === 'comparison'
+              ? 'bg-blue-50 border-blue-200 text-blue-700'
+              : 'bg-white border-slate-200 text-slate-600 hover:bg-slate-50'
+          }`}
+        >
+          用户对比
+        </button>
+      </div>
+    </div>
+  )
+}

src/renderer/src/components/report-analysis/export.ts

@@ -0,0 +1,50 @@
+/**
+ * Report Analysis Feature Module
+ * Centralized exports for the refactored report analysis components
+ */
+
+// Main component
+export { ReportAnalysisDialog, default } from './index'
+
+// Types
+export type {
+  ReportMetrics,
+  DailyMetrics,
+  UserDailyMetrics,
+  MetricKey,
+  ViewMode,
+  ReportAnalysisDialogProps,
+  CustomTooltipProps,
+  ComparisonTooltipProps
+} from './types'
+
+export { METRIC_LABELS, METRIC_COLORS, USER_COLORS } from './types'
+
+// Hooks
+export { useReportData } from './hooks/useReportData'
+export { useChartData } from './hooks/useChartData'
+export { useReportFilters } from './hooks/useReportFilters'
+
+// Components
+export { MetricSelector } from './components/MetricSelector'
+export { ViewModeToggle } from './components/ViewModeToggle'
+export { UserFilter } from './components/UserFilter'
+export { ReportChart } from './components/ReportChart'
+export { CustomTooltip } from './components/CustomTooltip'
+export { ComparisonTooltip } from './components/ComparisonTooltip'
+
+// Utilities
+export {
+  extractReportValues,
+  parseDurationToSeconds,
+  formatDateToChinese,
+  parseReportData
+} from './utils/parser'
+
+export {
+  aggregateByDate,
+  extractAllUsers,
+  aggregateByUserAndDate,
+  formatComparisonChartData,
+  getUserColor
+} from './utils/aggregators'

src/renderer/src/components/report-analysis/hooks/useChartData.ts

@@ -0,0 +1,59 @@
+/**
+ * Custom hook for transforming report data into chart-ready formats
+ * Handles data aggregation for different view modes
+ */
+
+import { useMemo } from 'react'
+import { ReportMetrics, DailyMetrics, UserDailyMetrics, MetricKey } from '../types'
+import {
+  aggregateByDate,
+  extractAllUsers,
+  aggregateByUserAndDate,
+  formatComparisonChartData
+} from '../utils/aggregators'
+
+interface UseChartDataResult {
+  chartData: DailyMetrics[]
+  allUsers: string[]
+  comparisonData: UserDailyMetrics[]
+  comparisonChartData: any[]
+}
+
+/**
+ * Hook for managing chart data transformations
+ *
+ * @param reportData - Raw report metrics data
+ * @param selectedUsers - Set of selected users for filtering
+ * @param selectedMetrics - Set of selected metrics to display
+ * @returns Transformed data ready for chart rendering
+ */
+export const useChartData = (
+  reportData: ReportMetrics[],
+  selectedUsers: Set<string>,
+  selectedMetrics: Set<MetricKey>
+): UseChartDataResult => {
+  // Aggregate data by date
+  const chartData = useMemo(() => aggregateByDate(reportData), [reportData])
+
+  // Extract all unique users from report data
+  const allUsers = useMemo(() => extractAllUsers(reportData), [reportData])
+
+  // Aggregate data by date AND user for comparison view
+  const comparisonData = useMemo(
+    () => aggregateByUserAndDate(reportData, selectedUsers),
+    [reportData, selectedUsers]
+  )
+
+  // Format comparison data for chart rendering
+  const comparisonChartData = useMemo(
+    () => formatComparisonChartData(comparisonData, selectedUsers, selectedMetrics),
+    [comparisonData, selectedUsers, selectedMetrics]
+  )
+
+  return {
+    chartData,
+    allUsers,
+    comparisonData,
+    comparisonChartData
+  }
+}

src/renderer/src/components/report-analysis/hooks/useReportData.ts

@@ -0,0 +1,106 @@
+/**
+ * Custom hook for fetching and managing report data
+ * Handles data loading, parsing, and error states
+ */
+
+import { useState, useCallback, useEffect } from 'react'
+import { ReportMetrics } from '../types'
+import { parseReportData } from '../utils/parser'
+
+interface UseReportDataResult {
+  isLoading: boolean
+  error: string | null
+  reportData: ReportMetrics[]
+  loadAndAnalyzeReports: () => Promise<void>
+  clearData: () => void
+}
+
+/**
+ * Hook for managing report data fetching and parsing
+ *
+ * @param isAdmin - Whether the current user has admin privileges
+ * @param isOpen - Whether the dialog is open
+ * @returns Report data state and control functions
+ */
+export const useReportData = (isAdmin: boolean, isOpen: boolean): UseReportDataResult => {
+  const [isLoading, setIsLoading] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+  const [reportData, setReportData] = useState<ReportMetrics[]>([])
+
+  const loadAndAnalyzeReports = useCallback(async () => {
+    if (!isAdmin) return
+
+    setIsLoading(true)
+    setError(null)
+
+    try {
+      // 1. Fetch report list
+      const listResult = await window.electron.report.listAll()
+      if (!listResult.success || !listResult.data) {
+        throw new Error(listResult.error || '获取报告列表失败')
+      }
+
+      const reports = listResult.data
+      const metricsList: ReportMetrics[] = []
+
+      // 2. Fetch content for each report (in chunks to avoid memory/network issues)
+      // Rule: async-parallel - Using Promise.all for parallel fetching
+      const chunkSize = 10
+      for (let i = 0; i < reports.length; i += chunkSize) {
+        const chunk = reports.slice(i, i + chunkSize)
+        const contentPromises = chunk.map(async (report) => {
+          try {
+            const contentResult = await window.electron.report.download(report.key)
+            if (contentResult.success && contentResult.data) {
+              return { report, content: contentResult.data }
+            }
+          } catch (e) {
+            console.warn(`Failed to fetch content for report ${report.key}`, e)
+          }
+          return null
+        })
+
+        const chunkContents = await Promise.all(contentPromises)
+
+        // 3. Parse each report's markdown content
+        // Rule: js-hoist-regexp - Regex patterns now in parseReportData function
+        for (const item of chunkContents) {
+          if (!item) continue
+
+          const { report, content } = item
+          const parsedData = parseReportData(report, content)
+
+          metricsList.push(parsedData)
+        }
+      }
+
+      setReportData(metricsList)
+    } catch (err: any) {
+      setError(err.message || '分析报告时发生错误')
+    } finally {
+      setIsLoading(false)
+    }
+  }, [isAdmin])
+
+  const clearData = useCallback(() => {
+    setReportData([])
+    setError(null)
+  }, [])
+
+  // Auto-load data when dialog opens
+  useEffect(() => {
+    if (isOpen && isAdmin) {
+      void loadAndAnalyzeReports()
+    } else {
+      clearData()
+    }
+  }, [isOpen, isAdmin, loadAndAnalyzeReports, clearData])
+
+  return {
+    isLoading,
+    error,
+    reportData,
+    loadAndAnalyzeReports,
+    clearData
+  }
+}

src/renderer/src/components/report-analysis/hooks/useReportFilters.ts

@@ -0,0 +1,122 @@
+/**
+ * Custom hook for managing report analysis filters and view modes
+ * Handles metric selection, view mode switching, and user filtering
+ */
+
+import { useState, useCallback } from 'react'
+import { MetricKey, ViewMode } from '../types'
+
+interface UseReportFiltersResult {
+  selectedMetrics: Set<MetricKey>
+  viewMode: ViewMode
+  selectedUsers: Set<string>
+  handleMetricToggle: (metric: MetricKey) => void
+  handleViewModeChange: (newMode: ViewMode) => void
+  handleUserToggle: (user: string) => void
+  handleSelectAllUsers: (users: string[]) => void
+  handleClearAllUsers: () => void
+}
+
+/**
+ * Hook for managing filter state and user interactions
+ *
+ * @returns Filter state and handler functions
+ */
+export const useReportFilters = (): UseReportFiltersResult => {
+  const [selectedMetrics, setSelectedMetrics] = useState<Set<MetricKey>>(
+    new Set(['processedOrders', 'deletedMaterials', 'errors'])
+  )
+
+  const [viewMode, setViewMode] = useState<ViewMode>('aggregated')
+
+  const [selectedUsers, setSelectedUsers] = useState<Set<string>>(new Set())
+
+  /**
+   * Handles metric selection with view mode awareness
+   * In comparison view: single selection only
+   * In aggregated view: multiple selection allowed
+   */
+  const handleMetricToggle = useCallback(
+    (metric: MetricKey) => {
+      setSelectedMetrics((prev) => {
+        const next = new Set(prev)
+
+        if (viewMode === 'comparison') {
+          // Single selection mode for comparison view
+          return new Set([metric])
+        } else {
+          // Multi-selection mode for aggregated view
+          if (next.has(metric)) {
+            // Ensure at least one metric is selected
+            if (next.size > 1) {
+              next.delete(metric)
+            }
+          } else {
+            next.add(metric)
+          }
+          return next
+        }
+      })
+    },
+    [viewMode]
+  )
+
+  /**
+   * Handles view mode switching with automatic metric adjustment
+   * When switching to comparison view, keeps only first selected metric
+   */
+  const handleViewModeChange = useCallback((newMode: ViewMode) => {
+    setViewMode(newMode)
+
+    // When switching to comparison view, keep only the first selected metric
+    if (newMode === 'comparison') {
+      setSelectedMetrics((prev) => {
+        if (prev.size > 1) {
+          const firstMetric = Array.from(prev)[0]
+          return new Set([firstMetric])
+        }
+        return prev
+      })
+    }
+  }, [])
+
+  /**
+   * Handles user selection toggle
+   */
+  const handleUserToggle = useCallback((user: string) => {
+    setSelectedUsers((prev) => {
+      const next = new Set(prev)
+      if (next.has(user)) {
+        next.delete(user)
+      } else {
+        next.add(user)
+      }
+      return next
+    })
+  }, [])
+
+  /**
+   * Selects all provided users
+   */
+  const handleSelectAllUsers = useCallback((users: string[]) => {
+    setSelectedUsers(new Set(users))
+  }, [])
+
+  /**
+   * Clears all user selections
+   */
+  const handleClearAllUsers = useCallback(() => {
+    setSelectedUsers(new Set())
+  }, [])
+
+  return {
+    selectedMetrics,
+    viewMode,
+    selectedUsers,
+    handleMetricToggle,
+    handleViewModeChange,
+    handleUserToggle,
+    handleSelectAllUsers,
+    handleClearAllUsers
+  }
+}

src/renderer/src/components/report-analysis/index.tsx

@@ -0,0 +1,211 @@
+/**
+ * ReportAnalysisDialog Component - Refactored
+ *
+ * A comprehensive dashboard for analyzing ERP system execution reports.
+ * Features include:
+ * - Aggregated view: Daily metrics overview
+ * - Comparison view: User performance comparison
+ * - Interactive filtering and metric selection
+ *
+ * This refactored version separates concerns into:
+ * - Custom hooks for business logic
+ * - Reusable components for UI
+ * - Utility functions for data processing
+ */
+
+import React, { useCallback } from 'react'
+import { X, BarChart3, Loader2, AlertCircle } from 'lucide-react'
+import { ReportAnalysisDialogProps, MetricKey } from './types'
+import { useReportData } from './hooks/useReportData'
+import { useChartData } from './hooks/useChartData'
+import { useReportFilters } from './hooks/useReportFilters'
+import { MetricSelector } from './components/MetricSelector'
+import { ViewModeToggle } from './components/ViewModeToggle'
+import { UserFilter } from './components/UserFilter'
+import { ReportChart } from './components/ReportChart'
+
+export const ReportAnalysisDialog: React.FC<ReportAnalysisDialogProps> = ({
+  isOpen,
+  onClose,
+  isAdmin
+}) => {
+  // Data management hook
+  const { isLoading, error, reportData, loadAndAnalyzeReports } = useReportData(isAdmin, isOpen)
+
+  // Filter state management hook
+  const {
+    selectedMetrics,
+    viewMode,
+    selectedUsers,
+    handleMetricToggle,
+    handleViewModeChange,
+    handleUserToggle,
+    handleSelectAllUsers: handleSelectAllUsersWithParam,
+    handleClearAllUsers
+  } = useReportFilters()
+
+  // Chart data transformation hook (must be called before using allUsers)
+  const { chartData, allUsers, comparisonChartData } = useChartData(
+    reportData,
+    selectedUsers,
+    selectedMetrics
+  )
+
+  // Adapt handleSelectAllUsers to match component interface
+  const handleSelectAllUsers = useCallback(() => {
+    handleSelectAllUsersWithParam(allUsers)
+  }, [allUsers, handleSelectAllUsersWithParam])
+
+  // Early returns for conditional rendering
+  if (!isOpen) return null
+  if (!isAdmin) return null
+
+  return (
+    <div className="fixed inset-0 z-[110] flex items-center justify-center bg-slate-900/50 backdrop-blur-sm animate-in fade-in duration-200">
+      <div className="bg-white rounded-2xl shadow-2xl w-[1000px] max-w-[95vw] h-[85vh] flex flex-col border border-slate-200 overflow-hidden animate-in zoom-in-95 duration-200">
+        {/* Header */}
+        <div className="flex items-center justify-between px-6 py-4 border-b border-slate-200 bg-slate-50 flex-shrink-0">
+          <div className="flex items-center gap-2 text-slate-800">
+            <BarChart3 size={20} className="text-blue-600" />
+            <h2 className="text-lg font-semibold">执行报告分析</h2>
+          </div>
+          <button
+            onClick={onClose}
+            className="text-slate-400 hover:text-slate-600 hover:bg-slate-200/50 p-1.5 rounded-lg transition-colors"
+          >
+            <X size={20} />
+          </button>
+        </div>
+
+        {/* Content */}
+        <div className="flex-1 overflow-hidden flex flex-col bg-white">
+          {isLoading ? (
+            <LoadingState />
+          ) : error ? (
+            <ErrorState error={error} onRetry={loadAndAnalyzeReports} />
+          ) : chartData.length === 0 ? (
+            <EmptyState />
+          ) : (
+            <MainContent
+              viewMode={viewMode}
+              selectedMetrics={selectedMetrics}
+              selectedUsers={selectedUsers}
+              allUsers={allUsers}
+              chartData={chartData}
+              comparisonChartData={comparisonChartData}
+              handleMetricToggle={handleMetricToggle}
+              handleViewModeChange={handleViewModeChange}
+              handleUserToggle={handleUserToggle}
+              handleSelectAllUsers={handleSelectAllUsers}
+              handleClearAllUsers={handleClearAllUsers}
+            />
+          )}
+        </div>
+      </div>
+    </div>
+  )
+}
+
+// ============================================================================
+// Sub-components for better organization
+// ============================================================================
+
+const LoadingState: React.FC = () => (
+  <div className="flex-1 flex flex-col items-center justify-center text-slate-500">
+    <Loader2 size={32} className="animate-spin text-blue-500 mb-4" />
+    <p>正在分析报告数据，可能需要几秒钟...</p>
+  </div>
+)
+
+const ErrorState: React.FC<{ error: string; onRetry: () => void }> = ({ error, onRetry }) => (
+  <div className="flex-1 flex flex-col items-center justify-center text-red-500 p-8 text-center">
+    <AlertCircle size={48} className="mb-4 opacity-80" />
+    <p className="text-lg font-medium mb-2">分析失败</p>
+    <p className="text-sm opacity-80">{error}</p>
+    <button
+      onClick={onRetry}
+      className="mt-6 px-4 py-2 bg-red-50 text-red-600 border border-red-200 rounded-lg hover:bg-red-100 transition-colors"
+    >
+      重试
+    </button>
+  </div>
+)
+
+const EmptyState: React.FC = () => (
+  <div className="flex-1 flex flex-col items-center justify-center text-slate-400">
+    <BarChart3 size={48} className="mb-4 opacity-50 text-slate-300" />
+    <p>暂无报告数据可供分析</p>
+  </div>
+)
+
+interface MainContentProps {
+  viewMode: 'aggregated' | 'comparison'
+  selectedMetrics: Set<MetricKey>
+  selectedUsers: Set<string>
+  allUsers: string[]
+  chartData: any[]
+  comparisonChartData: any[]
+  handleMetricToggle: (metric: MetricKey) => void
+  handleViewModeChange: (newMode: 'aggregated' | 'comparison') => void
+  handleUserToggle: (user: string) => void
+  handleSelectAllUsers: () => void
+  handleClearAllUsers: () => void
+}
+
+const MainContent: React.FC<MainContentProps> = ({
+  viewMode,
+  selectedMetrics,
+  selectedUsers,
+  allUsers,
+  chartData,
+  comparisonChartData,
+  handleMetricToggle,
+  handleViewModeChange,
+  handleUserToggle,
+  handleSelectAllUsers,
+  handleClearAllUsers
+}) => (
+  <div className="flex-1 flex flex-col p-6 overflow-y-auto">
+    {/* Metric Selector */}
+    <MetricSelector
+      selectedMetrics={selectedMetrics}
+      viewMode={viewMode}
+      onMetricToggle={handleMetricToggle}
+    />
+
+    {/* View Mode Toggle */}
+    <ViewModeToggle viewMode={viewMode} onViewModeChange={handleViewModeChange} />
+
+    {/* User Filter - Only in comparison mode */}
+    {viewMode === 'comparison' && (
+      <UserFilter
+        allUsers={allUsers}
+        selectedUsers={selectedUsers}
+        onUserToggle={handleUserToggle}
+        onSelectAll={handleSelectAllUsers}
+        onClearAll={handleClearAllUsers}
+      />
+    )}
+
+    {/* Chart */}
+    <ReportChart
+      viewMode={viewMode}
+      selectedMetrics={selectedMetrics}
+      selectedUsers={selectedUsers}
+      allUsers={allUsers}
+      chartData={chartData}
+      comparisonChartData={comparisonChartData}
+    />
+
+    {/* Description */}
+    <div className="mt-4 text-center text-xs text-slate-400">
+      {viewMode === 'aggregated'
+        ? '数据以天为单位进行聚合统计。展示的是选定时间段内的总量。'
+        : selectedUsers.size === 0
+          ? '展示所有用户的数据对比。未选择用户时显示全部。'
+          : '展示选定用户的数据对比。'}
+    </div>
+  </div>
+)
+
+export default ReportAnalysisDialog

src/renderer/src/components/report-analysis/types.ts

@@ -0,0 +1,153 @@
+/**
+ * Type definitions for Report Analysis feature
+ * Centralized type management for better maintainability
+ */
+
+// ============================================================================
+// Domain Types
+// ============================================================================
+
+/**
+ * Extracted metrics from a single report
+ */
+export interface ReportMetrics {
+  date: string
+  user: string
+  processedOrders: number
+  deletedMaterials: number
+  skippedMaterials: number
+  errors: number
+  retriedOrders: number
+  successfulRetries: number
+  executionTimeSecs: number
+  timestamp: number
+}
+
+/**
+ * Aggregated daily metrics
+ */
+export interface DailyMetrics {
+  date: string
+  processedOrders: number
+  deletedMaterials: number
+  skippedMaterials: number
+  errors: number
+  retriedOrders: number
+  successfulRetries: number
+  executionTimeSecs: number
+  avgExecutionTimeSecs: number
+  users: string[] // Unique users who ran reports on this day
+  reportCount: number
+}
+
+/**
+ * User-specific daily metrics for comparison view
+ */
+export interface UserDailyMetrics {
+  date: string
+  user: string
+  processedOrders: number
+  deletedMaterials: number
+  skippedMaterials: number
+  errors: number
+  retriedOrders: number
+  successfulRetries: number
+  executionTimeSecs: number
+  reportCount: number
+}
+
+// ============================================================================
+// UI Types
+// ============================================================================
+
+/**
+ * Available metric keys for chart display
+ */
+export type MetricKey = keyof Omit<
+  DailyMetrics,
+  'date' | 'users' | 'reportCount' | 'avgExecutionTimeSecs'
+>
+
+/**
+ * View mode for the analysis display
+ */
+export type ViewMode = 'aggregated' | 'comparison'
+
+// ============================================================================
+// Component Props Types
+// ============================================================================
+
+/**
+ * Props for the main ReportAnalysisDialog component
+ */
+export interface ReportAnalysisDialogProps {
+  isOpen: boolean
+  onClose: () => void
+  isAdmin: boolean
+}
+
+/**
+ * Props for custom tooltip component
+ */
+export interface CustomTooltipProps {
+  active?: boolean
+  payload?: any[]
+  label?: string
+  chartData: DailyMetrics[]
+}
+
+/**
+ * Props for comparison tooltip component
+ */
+export interface ComparisonTooltipProps {
+  active?: boolean
+  payload?: any[]
+  label?: string
+  users: string[]
+  selectedUsers: Set<string>
+  selectedMetrics: Set<MetricKey>
+}
+
+// ============================================================================
+// Configuration Types
+// ============================================================================
+
+/**
+ * Metric labels mapping
+ */
+export const METRIC_LABELS: Record<MetricKey, string> = {
+  processedOrders: '处理订单数',
+  deletedMaterials: '删除物料数',
+  skippedMaterials: '跳过物料数',
+  errors: '错误数量',
+  retriedOrders: '重试订单数',
+  successfulRetries: '成功重试数',
+  executionTimeSecs: '每订单平均耗时(秒)'
+}
+
+/**
+ * Metric colors mapping
+ */
+export const METRIC_COLORS: Record<MetricKey, string> = {
+  processedOrders: '#3b82f6', // blue-500
+  deletedMaterials: '#ef4444', // red-500
+  skippedMaterials: '#eab308', // yellow-500
+  errors: '#000000', // black
+  retriedOrders: '#8b5cf6', // violet-500
+  successfulRetries: '#10b981', // emerald-500
+  executionTimeSecs: '#f97316' // orange-500
+}
+
+/**
+ * User colors for comparison view
+ */
+export const USER_COLORS = [
+  '#3b82f6', // blue-500
+  '#10b981', // emerald-500
+  '#f59e0b', // amber-500
+  '#ef4444', // red-500
+  '#8b5cf6', // violet-500
+  '#ec4899', // pink-500
+  '#06b6d4', // cyan-500
+  '#84cc16' // lime-500
+]

src/renderer/src/components/report-analysis/utils/aggregators.ts

@@ -0,0 +1,202 @@
+/**
+ * Data aggregation utilities for transforming raw report data
+ * Handles date-based and user-based aggregations
+ */
+
+import { ReportMetrics, DailyMetrics, UserDailyMetrics, MetricKey } from '../types'
+
+// ============================================================================
+// Aggregation Functions
+// ============================================================================
+
+/**
+ * Aggregates report data by date for the overview chart
+ * Calculates totals and averages for each day
+ *
+ * @param reportData - Array of individual report metrics
+ * @returns Array of daily aggregated metrics sorted by date
+ */
+export const aggregateByDate = (reportData: ReportMetrics[]): DailyMetrics[] => {
+  if (!reportData.length) return []
+
+  const dailyMap = new Map<string, DailyMetrics>()
+
+  // First pass: aggregate by date
+  for (const data of reportData) {
+    const { date } = data
+
+    if (!dailyMap.has(date)) {
+      dailyMap.set(date, {
+        date,
+        processedOrders: 0,
+        deletedMaterials: 0,
+        skippedMaterials: 0,
+        errors: 0,
+        retriedOrders: 0,
+        successfulRetries: 0,
+        executionTimeSecs: 0,
+        avgExecutionTimeSecs: 0,
+        users: [],
+        reportCount: 0
+      })
+    }
+
+    const day = dailyMap.get(date)!
+    day.processedOrders += data.processedOrders
+    day.deletedMaterials += data.deletedMaterials
+    day.skippedMaterials += data.skippedMaterials
+    day.errors += data.errors
+    day.retriedOrders += data.retriedOrders
+    day.successfulRetries += data.successfulRetries
+    day.executionTimeSecs += data.executionTimeSecs
+    day.reportCount += 1
+
+    if (!day.users.includes(data.user)) {
+      day.users.push(data.user)
+    }
+  }
+
+  // Second pass: calculate averages
+  for (const day of dailyMap.values()) {
+    day.avgExecutionTimeSecs =
+      day.processedOrders > 0 ? day.executionTimeSecs / day.processedOrders : 0
+    // Replace executionTimeSecs with avgExecutionTimeSecs for chart display
+    day.executionTimeSecs = day.avgExecutionTimeSecs
+  }
+
+  // Convert map to array and sort by date
+  return Array.from(dailyMap.values()).sort((a, b) => a.date.localeCompare(b.date))
+}
+
+/**
+ * Extracts all unique users from report data
+ *
+ * @param reportData - Array of individual report metrics
+ * @returns Sorted array of unique usernames
+ */
+export const extractAllUsers = (reportData: ReportMetrics[]): string[] => {
+  const userSet = new Set<string>()
+  reportData.forEach((data) => userSet.add(data.user))
+  return Array.from(userSet).sort()
+}
+
+/**
+ * Aggregates report data by date AND user for comparison view
+ * Allows comparing multiple users across the same time periods
+ *
+ * @param reportData - Array of individual report metrics
+ * @param selectedUsers - Set of selected users for filtering (empty = all)
+ * @returns Array of user-daily aggregated metrics sorted by date and user
+ */
+export const aggregateByUserAndDate = (
+  reportData: ReportMetrics[],
+  selectedUsers: Set<string>
+): UserDailyMetrics[] => {
+  if (!reportData.length) return []
+
+  // Filter by selected users if any
+  const filteredData =
+    selectedUsers.size > 0 ? reportData.filter((data) => selectedUsers.has(data.user)) : reportData
+
+  // Group by date + user
+  const keyMap = new Map<string, UserDailyMetrics>()
+
+  for (const data of filteredData) {
+    const key = `${data.date}|${data.user}`
+
+    if (!keyMap.has(key)) {
+      keyMap.set(key, {
+        date: data.date,
+        user: data.user,
+        processedOrders: 0,
+        deletedMaterials: 0,
+        skippedMaterials: 0,
+        errors: 0,
+        retriedOrders: 0,
+        successfulRetries: 0,
+        executionTimeSecs: 0,
+        reportCount: 0
+      })
+    }
+
+    const entry = keyMap.get(key)!
+    entry.processedOrders += data.processedOrders
+    entry.deletedMaterials += data.deletedMaterials
+    entry.skippedMaterials += data.skippedMaterials
+    entry.errors += data.errors
+    entry.retriedOrders += data.retriedOrders
+    entry.successfulRetries += data.successfulRetries
+    entry.executionTimeSecs += data.executionTimeSecs
+    entry.reportCount += 1
+  }
+
+  // Calculate average execution time per order for each entry
+  for (const entry of keyMap.values()) {
+    entry.executionTimeSecs =
+      entry.processedOrders > 0 ? entry.executionTimeSecs / entry.processedOrders : 0
+  }
+
+  return Array.from(keyMap.values()).sort((a, b) => {
+    const dateCompare = a.date.localeCompare(b.date)
+    if (dateCompare !== 0) return dateCompare
+    return a.user.localeCompare(b.user)
+  })
+}
+
+/**
+ * Formats comparison data for chart rendering
+ * Transforms user-date data into a format suitable for Recharts
+ *
+ * @param comparisonData - Array of user-daily aggregated metrics
+ * @param selectedUsers - Set of selected users for filtering
+ * @param selectedMetrics - Set of selected metrics to display
+ * @returns Array of chart data points formatted for Recharts
+ */
+export const formatComparisonChartData = (
+  comparisonData: UserDailyMetrics[],
+  selectedUsers: Set<string>,
+  selectedMetrics: Set<MetricKey>
+): any[] => {
+  if (!comparisonData.length) return []
+
+  const dates = [...new Set(comparisonData.map((d) => d.date))].sort()
+  const users = [...new Set(comparisonData.map((d) => d.user))]
+    .filter((user) => selectedUsers.size === 0 || selectedUsers.has(user))
+    .sort()
+
+  const lookup = new Map<string, UserDailyMetrics>()
+  comparisonData.forEach((d) => {
+    lookup.set(`${d.date}|${d.user}`, d)
+  })
+
+  return dates.map((date) => {
+    const point: any = { date }
+    users.forEach((user) => {
+      const key = `${date}|${user}`
+      const data = lookup.get(key)
+
+      Array.from(selectedMetrics).forEach((metric) => {
+        const userKey = `${user}_${metric}` as any
+        point[userKey] = data ? (data as any)[metric] : 0
+      })
+    })
+    return point
+  })
+}
+
+// ============================================================================
+// Utility Functions
+// ============================================================================
+
+/**
+ * Gets a consistent color for a user based on their position in the list
+ *
+ * @param user - Username to get color for
+ * @param users - Array of all users (for consistent indexing)
+ * @param colors - Array of color values to cycle through
+ * @returns Color hex string
+ */
+export const getUserColor = (user: string, users: string[], colors: string[]): string => {
+  const index = users.indexOf(user)
+  return colors[index % colors.length]
+}

src/renderer/src/components/report-analysis/utils/parser.ts

@@ -0,0 +1,178 @@
+/**
+ * Parser utilities for extracting report data from markdown content
+ * Optimized for performance with pre-compiled regex patterns
+ */
+
+// ============================================================================
+// Result Types
+// ============================================================================
+
+interface ExtractValueResult {
+  execTimeStr: string | null
+  user: string
+  processedOrders: number
+  deletedMaterials: number
+  skippedMaterials: number
+  errors: number
+  retriedOrders: number
+  successfulRetries: number
+  executionTimeStr: string
+}
+
+interface ParsedReportData {
+  date: string
+  user: string
+  processedOrders: number
+  deletedMaterials: number
+  skippedMaterials: number
+  errors: number
+  retriedOrders: number
+  successfulRetries: number
+  executionTimeSecs: number
+  timestamp: number
+}
+
+// ============================================================================
+// Parser Functions
+// ============================================================================
+
+/**
+ * Extracts values from markdown report content using pre-compiled regex patterns.
+ * Patterns are created once and reused for better performance.
+ *
+ * @param content - The markdown content to parse
+ * @returns Extracted metrics values
+ */
+export const extractReportValues = (content: string): ExtractValueResult => {
+  // Pre-compile regex patterns for better performance (js-hoist-regexp)
+  const createPattern = (key: string) => ({
+    standard: new RegExp(`\\|\\s*\\*\\*${key}\\*\\*\\s*\\|\\s*\`([^\`]+)\`\\s*\\|`),
+    noBackticks: new RegExp(
+      `\\|\\s*\\*\\*${key}\\*\\*\\s*\\|\\s*([^\\|\\s]+(?:\\s+[^\\|\\s]+)*)\\s*\\|`
+    ),
+    relaxed: new RegExp(`\\|\\s*\\*\\*${key}\\*\\*\\s*\\|\\s*(.+?)\\s*\\|`)
+  })
+
+  const extractValue = (key: string): string | null => {
+    const patterns = createPattern(key)
+
+    for (const pattern of Object.values(patterns)) {
+      const match = content.match(pattern)
+      if (match && match[1]) {
+        const value = match[1].trim()
+        return value.replace(/`/g, '')
+      }
+    }
+    return null
+  }
+
+  return {
+    execTimeStr: extractValue('执行时间'),
+    user: extractValue('操作用户') || 'unknown',
+    processedOrders: parseInt(extractValue('处理订单数') || '0', 10),
+    deletedMaterials: parseInt(extractValue('删除物料数') || '0', 10),
+    skippedMaterials: parseInt(extractValue('跳过物料数') || '0', 10),
+    errors: parseInt(extractValue('错误数量') || '0', 10),
+    retriedOrders: parseInt(extractValue('重试订单数') || '0', 10),
+    successfulRetries: parseInt(extractValue('成功重试数') || '0', 10),
+    executionTimeStr: extractValue('执行耗时') || '0秒'
+  }
+}
+
+/**
+ * Parses duration string (e.g., "5分30秒", "120秒") to total seconds
+ *
+ * @param durationStr - Duration string to parse
+ * @returns Total seconds
+ */
+export const parseDurationToSeconds = (durationStr: string): number => {
+  // Handle empty or zero case
+  if (!durationStr || durationStr === '0秒' || durationStr === '0分0秒') {
+    return 0
+  }
+
+  // Remove any remaining backticks
+  const cleanStr = durationStr.replace(/`/g, '').trim()
+
+  let totalSeconds = 0
+  const minutesMatch = cleanStr.match(/(\d+)分/)
+  if (minutesMatch) {
+    totalSeconds += parseInt(minutesMatch[1], 10) * 60
+  }
+  const secondsMatch = cleanStr.match(/(\d+)秒/)
+  if (secondsMatch) {
+    totalSeconds += parseInt(secondsMatch[1], 10)
+  }
+
+  return totalSeconds
+}
+
+/**
+ * Formats a date object to Chinese date string format (YYYY-MM-DD)
+ *
+ * @param date - Date object to format
+ * @returns Formatted date string
+ */
+export const formatDateToChinese = (date: Date): string => {
+  return date
+    .toLocaleDateString('zh-CN', {
+      year: 'numeric',
+      month: '2-digit',
+      day: '2-digit'
+    })
+    .replace(/\//g, '-')
+}
+
+/**
+ * Parses report metadata and content into a structured ReportMetrics object
+ *
+ * @param report - Report metadata with key, username, lastModified
+ * @param content - Markdown content of the report
+ * @returns Parsed report metrics
+ */
+export const parseReportData = (
+  report: { key: string; username?: string; lastModified?: string | number | Date },
+  content: string
+): ParsedReportData => {
+  const values = extractReportValues(content)
+  const user = values.user || report.username || 'unknown'
+  const executionTimeSecs = parseDurationToSeconds(values.executionTimeStr)
+
+  if (values.executionTimeStr === '0秒') {
+    console.warn('Failed to extract execution time from report:', report.key)
+  }
+
+  // Try to parse the date
+  let dateStr = '未知日期'
+  let timestamp = report.lastModified ? new Date(report.lastModified).getTime() : 0
+
+  if (values.execTimeStr) {
+    try {
+      const parsedDate = new Date(values.execTimeStr)
+      if (!isNaN(parsedDate.getTime())) {
+        dateStr = formatDateToChinese(parsedDate)
+        timestamp = parsedDate.getTime()
+      }
+    } catch {
+      // Fallback to report lastModified
+    }
+  }
+
+  if (dateStr === '未知日期' && report.lastModified) {
+    const d = new Date(report.lastModified)
+    dateStr = formatDateToChinese(d)
+  }
+
+  return {
+    date: dateStr,
+    user,
+    processedOrders: values.processedOrders,
+    deletedMaterials: values.deletedMaterials,
+    skippedMaterials: values.skippedMaterials,
+    errors: values.errors,
+    retriedOrders: values.retriedOrders,
+    successfulRetries: values.successfulRetries,
+    executionTimeSecs,
+    timestamp
+  }
+}

src/renderer/src/hooks/useAppBootstrap.ts

@@ -17,7 +17,7 @@ export interface CurrentUser {
 export interface SelectedUserInfo {
   id: number
   username: string
-  userType: 'Admin' | 'User' | 'Guest'
+  userType: 'Admin' | 'User'
   computerName?: string
 }
 

src/renderer/src/hooks/useAuth.ts

@@ -3,7 +3,7 @@ import { useState, useCallback } from 'react'
 interface UserInfo {
   id: number
   username: string
-  userType: 'Admin' | 'User' | 'Guest'
+  userType: 'Admin' | 'User'
   computerName?: string
 }
 

src/renderer/src/pages/ExtractorPage.tsx

@@ -1,14 +1,18 @@
 import React from 'react'
-import { Download, Play, CheckCircle } from 'lucide-react'
+import { Download, Play, CheckCircle, History } from 'lucide-react'
 import OrderNumberInput from '../components/OrderNumberInput'
 import { useExtractor } from '../hooks/useExtractor'
 import { usePersistentTextState } from '../hooks/usePersistentTextState'
 import { useSharedProductionIds } from '../hooks/useSharedProductionIds'
 import LogPanel from '../components/ui/LogPanel'
 import { SegmentedProgressBar } from '../components/ui/SegmentedProgressBar'
+import ExtractorOperationHistoryModal from '../components/ExtractorOperationHistoryModal'
+import { useUserStore } from '../stores/useUserStore'
 
 const ExtractorPage: React.FC = () => {
   const [orderNumbers, setOrderNumbers] = usePersistentTextState('extractor_orderNumbers')
+  const [showHistoryModal, setShowHistoryModal] = React.useState(false)
+  const user = useUserStore((state) => state.user)
 
   const {
     isRunning,
@@ -67,6 +71,14 @@ const ExtractorPage: React.FC = () => {
           </div>
 
           <div className="flex items-center gap-4">
+            <button
+              className="bg-slate-100 hover:bg-slate-200 text-slate-700 px-4 py-2.5 rounded-lg flex items-center gap-2 font-medium transition-colors"
+              onClick={() => setShowHistoryModal(true)}
+              disabled={isRunning}
+            >
+              <History size={18} />
+              操作历史
+            </button>
             <button
               className="bg-blue-600 hover:bg-blue-700 disabled:opacity-50 text-white px-6 py-2.5 rounded-lg flex items-center gap-2 font-medium shadow-sm transition-colors"
               onClick={handleExtract}
@@ -78,6 +90,14 @@ const ExtractorPage: React.FC = () => {
           </div>
         </div>
 
+        {showHistoryModal && (
+          <ExtractorOperationHistoryModal
+            isOpen={showHistoryModal}
+            onClose={() => setShowHistoryModal(false)}
+            user={user}
+          />
+        )}
+
         {!isRunning && isComplete && (
           <div className="bg-green-50 rounded-xl p-8 flex items-center justify-center gap-4 shadow-md">
             <CheckCircle className="text-green-600" size={35} />

src/renderer/src/stores/useUserStore.ts

@@ -10,7 +10,7 @@ import { create } from 'zustand'
 interface UserInfo {
   id: number
   username: string
-  userType: 'Admin' | 'User' | 'Guest'
+  userType: 'Admin' | 'User'
   computerName?: string
 }
 

src/shared/ipc-channels.ts

@@ -111,7 +111,12 @@ export const IPC_CHANNELS = {
   PLAYWRIGHT_BROWSER_DOWNLOAD: 'playwright-browser:download',
   PLAYWRIGHT_BROWSER_CANCEL: 'playwright-browser:cancel',
   PLAYWRIGHT_BROWSER_PROGRESS: 'playwright-browser:progress',
-  PLAYWRIGHT_BROWSER_CHECK: 'playwright-browser:check'
+  PLAYWRIGHT_BROWSER_CHECK: 'playwright-browser:check',
+
+  // Operation History
+  OPERATION_HISTORY_GET_BATCHES: 'operationHistory:getBatches',
+  OPERATION_HISTORY_GET_BATCH_DETAILS: 'operationHistory:getBatchDetails',
+  OPERATION_HISTORY_DELETE_BATCH: 'operationHistory:deleteBatch'
 } as const
 
 /**