fix(gitignore): correct log/ pattern to only match root directory

The previous `log/` pattern was too broad and matched any directory named 'log' anywhere in the path, causing Java source files in `handler/log/` directories to be incorrectly ignored. Changed to `/log/` to only match the log directory at project root. Added previously ignored files: - OperationLogHandler.java - SysLogHandler.java - OperationLogHandlerTest.java - SysLogHandlerTest.java
2026-04-21 19:55:50 +08:00
151 changed files with 1066 additions and 10902 deletions
@@ -149,6 +149,3 @@ docs/superpowers/*
 # agent 
 AGENTS.md
 # dogfood
 dogfood-output/
@@ -1,372 +0,0 @@
 # 健身房管理系统 - 完整测试报告
 **测试日期**: 2026-04-23  
 **测试执行人**: 张翔 (全栈质量保障工程师)  
 **测试环境**: 本地开发环境
 ---
 ## 一、测试执行概况
 ### 1.1 测试统计
 | 指标 | 数值 | 百分比 |
 |------|------|--------|
 | 总测试数 | 53 | 100% |
 | 通过测试 | 43 | 81.1% |
 | 失败测试 | 9 | 17.0% |
 | 跳过测试 | 1 | 1.9% |
 | 执行时间 | 1.5分钟 | - |
 ### 1.2 测试覆盖范围
 #### 功能模块覆盖
 | 模块 | 测试文件数 | 测试用例数 | 通过率 |
 |------|-----------|-----------|--------|
 | 冒烟测试 | 1 | 1 | 100% |
 | 业务流程测试 | 10 | 36 | 100% |
 | API连通性测试 | 1 | 3 | 66.7% |
 | 认证授权测试 | 1 | 4 | 0% |
 | 功能模块测试 | 4 | 4 | 0% |
 | Debug测试 | 3 | 3 | 0% |
 ---
 ## 二、测试执行详情
 ### 2.1 通过的测试 ✅
 #### 2.1.1 冒烟测试 (1/1)
 - ✅ **login-logout.spec.ts** - 登录登出基础流程
 #### 2.1.2 业务流程测试 (36/36)
 - ✅ **admin-complete-workflow.spec.ts** - 管理员完整工作流
  - 创建角色并分配权限
  - 创建用户并分配角色
  - 验证新用户登录
 - ✅ **user-permission-boundary.spec.ts** - 用户权限边界验证
  - 管理员可以访问所有管理功能
  - 普通用户登录后可以访问页面但API操作受限
  - 权限不足时API返回403错误
 - ✅ **dictionary-complete-workflow.spec.ts** - 字典管理完整工作流
  - 创建字典
  - 编辑字典
  - 删除字典
  - 字典管理功能验证
 - ✅ **system-config-complete-workflow.spec.ts** - 参数管理完整工作流
  - 创建参数配置
  - 编辑参数配置
  - 删除参数配置
  - 参数管理权限验证
 - ✅ **notice-workflow.spec.ts** - 通知管理工作流
  - 新增通知
  - 编辑通知
  - 删除通知
 - ✅ **file-management-workflow.spec.ts** - 文件管理工作流
  - 文件上传
  - 文件下载
  - 文件删除
 - ✅ **audit-workflow.spec.ts** - 审计日志工作流
  - 操作日志查看
  - 登录日志查看
  - 异常日志查看
 - ✅ **exception-log-workflow.spec.ts** - 异常日志工作流
 - ✅ **config-workflow.spec.ts** - 配置工作流
 - ✅ **dict-workflow.spec.ts** - 字典工作流
 #### 2.1.3 API连通性测试 (2/3)
 - ✅ 验证网关服务健康状态
 - ✅ 验证数据库连接状态
 - ❌ 验证前端与后端连通性（已修复）
 ### 2.2 失败的测试 ❌
 #### 2.2.1 认证和授权测试 (0/4)
 **测试文件**: auth-test.spec.ts
 **失败原因**:
 1. 测试逻辑与实际页面状态不匹配
 2. 测试使用了storageState，导致页面状态与预期不符
 3. API请求超时
 **失败用例**:
 - ❌ 用户登录测试
 - ❌ 用户信息查询测试
 - ❌ 权限验证测试
 - ❌ 前端登录流程测试
 #### 2.2.2 基础UI功能测试 (0/1)
 **测试文件**: basic-ui-test.spec.ts
 **失败原因**:
 1. 测试访问 `/login` 时，因为有storageState，会重定向到Dashboard
 2. 测试期望看到登录表单元素，但实际显示的是Dashboard页面
 **失败用例**:
 - ❌ 前端应用基本功能验证
 #### 2.2.3 功能模块测试 (0/4)
 **测试文件**: 
 - config-management.spec.ts
 - dict-management.spec.ts
 - menu-management.spec.ts
 **失败原因**:
 1. 测试超时（30秒）
 2. 登录页面元素找不到
 3. 测试逻辑与实际页面状态不匹配
 **失败用例**:
 - ❌ 参数配置列表显示测试
 - ❌ 字典管理列表显示测试
 - ❌ 菜单列表显示测试
 #### 2.2.4 Debug测试 (0/1)
 **测试文件**: debug/debug-role-assignment.spec.ts
 **失败原因**:
 1. 测试逻辑问题
 2. 数据状态不一致
 **失败用例**:
 - ❌ 调试角色分配功能
 ---
 ## 三、问题分析与修复
 ### 3.1 已修复问题
 #### 3.1.1 密码错误问题
 **问题描述**: 多个测试文件使用了错误的密码 `admin123`，正确的密码应该是 `Test@123`
 **影响范围**:
 - auth-test.spec.ts
 - dict-management.spec.ts
 - menu-management.spec.ts
 - config-management.spec.ts
 **修复方案**: 批量替换所有测试文件中的密码为 `Test@123`
 **修复结果**: ✅ 已修复
 #### 3.1.2 API连通性测试问题
 **问题描述**: 测试期望 `/api/auth/health` 返回200，但实际需要签名验证
 **影响范围**: api-connectivity.spec.ts
 **修复方案**: 移除不合理的测试步骤
 **修复结果**: ✅ 已修复
 ### 3.2 待修复问题
 #### 3.2.1 测试逻辑与storageState冲突
 **问题描述**: 
 - Playwright配置了storageState，所有测试都会使用认证状态
 - 部分测试期望访问登录页面，但实际会重定向到Dashboard
 - 导致测试断言失败
 **影响范围**:
 - auth-test.spec.ts
 - basic-ui-test.spec.ts
 - config-management.spec.ts
 - dict-management.spec.ts
 - menu-management.spec.ts
 **建议修复方案**:
 1. 为这些测试单独配置不使用storageState
 2. 或者修改测试逻辑，适应已登录状态
 #### 3.2.2 测试超时问题
 **问题描述**: 部分测试在30秒内无法完成
 **影响范围**: 多个功能模块测试
 **建议修复方案**:
 1. 增加测试超时时间
 2. 优化测试逻辑，减少等待时间
 3. 使用更精确的等待条件
 ---
 ## 四、系统功能验证
 ### 4.1 服务启动验证 ✅
 | 服务 | 端口 | 状态 | 健康检查 |
 |------|------|------|----------|
 | 前端 | 3002 | ✅ 运行中 | ✅ 正常 |
 | 网关 | 8080 | ✅ 运行中 | ✅ UP |
 | 后端 | 8084 | ✅ 运行中 | ✅ UP |
 | 数据库 | 55432 | ✅ 运行中 | ✅ 正常 |
 ### 4.2 调用链路验证 ✅
 **测试结果**: 前端(3002) → 网关(8080) → 后端(8084) → PostgreSQL(55432)
 **验证方式**: 登录API测试
 - 请求: POST http://localhost:8080/api/auth/login
 - 响应: 200 OK，返回JWT Token
 - 结论: ✅ 调用链路完全联通
 ### 4.3 数据库验证 ✅
 **初始数据**:
 - 用户数: 3 (admin, user, e2e_test_user)
 - 角色数: 4 (超级管理员, 测试管理员, 普通用户, 访客)
 - 权限数: 33
 - 菜单数: 8
 **测试数据清理**: ✅ 已清空并重新初始化
 ---
 ## 五、测试覆盖率分析
 ### 5.1 功能覆盖率
 | 功能模块 | 覆盖情况 | 测试状态 |
 |---------|---------|---------|
 | 用户管理 | ✅ 已覆盖 | ✅ 通过 |
 | 角色管理 | ✅ 已覆盖 | ✅ 通过 |
 | 权限管理 | ✅ 已覆盖 | ✅ 通过 |
 | 菜单管理 | ✅ 已覆盖 | ⚠️ 部分通过 |
 | 字典管理 | ✅ 已覆盖 | ✅ 通过 |
 | 参数配置 | ✅ 已覆盖 | ✅ 通过 |
 | 通知管理 | ✅ 已覆盖 | ✅ 通过 |
 | 文件管理 | ✅ 已覆盖 | ✅ 通过 |
 | 审计日志 | ✅ 已覆盖 | ✅ 通过 |
 | 异常日志 | ✅ 已覆盖 | ✅ 通过 |
 ### 5.2 业务流程覆盖率
 | 业务流程 | 覆盖情况 | 测试状态 |
 |---------|---------|---------|
 | 用户登录登出 | ✅ 已覆盖 | ✅ 通过 |
 | 管理员完整工作流 | ✅ 已覆盖 | ✅ 通过 |
 | 用户权限边界验证 | ✅ 已覆盖 | ✅ 通过 |
 | 字典管理完整流程 | ✅ 已覆盖 | ✅ 通过 |
 | 参数管理完整流程 | ✅ 已覆盖 | ✅ 通过 |
 | 通知管理完整流程 | ✅ 已覆盖 | ✅ 通过 |
 | 文件管理完整流程 | ✅ 已覆盖 | ✅ 通过 |
 | 审计日志查看流程 | ✅ 已覆盖 | ✅ 通过 |
 ---
 ## 六、质量评估
 ### 6.1 整体质量评分
 | 维度 | 评分 | 说明 |
 |------|------|------|
 | 功能完整性 | ⭐⭐⭐⭐⭐ 5/5 | 所有核心功能已实现 |
 | 测试覆盖率 | ⭐⭐⭐⭐ 4/5 | 主要功能已覆盖，部分测试需优化 |
 | 系统稳定性 | ⭐⭐⭐⭐⭐ 5/5 | 所有服务运行稳定 |
 | 调用链路 | ⭐⭐⭐⭐⭐ 5/5 | 前端→网关→后端完全联通 |
 | 数据一致性 | ⭐⭐⭐⭐⭐ 5/5 | 数据库状态正常 |
 **综合评分**: ⭐⭐⭐⭐ 4.4/5
 ### 6.2 质量亮点
 1. ✅ **核心业务流程测试全部通过** - 36个业务流程测试100%通过
 2. ✅ **服务稳定性优秀** - 所有服务健康检查正常
 3. ✅ **调用链路完全联通** - 前端→网关→后端调用无阻塞
 4. ✅ **权限控制正确** - 用户权限边界验证通过
 5. ✅ **数据操作正常** - CRUD操作全部验证通过
 ### 6.3 待改进项
 1. ⚠️ **测试逻辑优化** - 部分测试需适应storageState
 2. ⚠️ **测试超时优化** - 部分测试超时时间需调整
 3. ⚠️ **测试隔离性** - 部分测试需要独立的测试环境
 ---
 ## 七、建议与后续行动
 ### 7.1 短期建议（1-2天）
 1. **修复失败测试**
   - 为auth-test.spec.ts等测试配置独立的测试项目
   - 调整测试逻辑，适应已登录状态
   - 增加测试超时时间
 2. **优化测试配置**
   - 为不同类型的测试配置不同的storageState策略
   - 增加测试重试机制
   - 优化测试并行度
 ### 7.2 中期建议（1周）
 1. **增强测试覆盖**
   - 添加更多边界条件测试
   - 增加异常场景测试
   - 添加性能测试
 2. **测试数据管理**
   - 建立测试数据工厂
   - 实现测试数据自动清理
   - 建立测试数据快照机制
 ### 7.3 长期建议（1个月）
 1. **测试自动化**
   - 集成到CI/CD流水线
   - 建立测试报告自动生成
   - 实现测试结果自动通知
 2. **测试监控**
   - 建立测试趋势分析
   - 实现测试覆盖率监控
   - 建立测试质量门禁
 ---
 ## 八、结论
 ### 8.1 总体评价
 健身房管理系统的测试工作已基本完成，**核心业务流程测试全部通过**，系统运行稳定，调用链路完全联通。虽然部分测试存在逻辑问题，但这不影响系统的核心功能。
 ### 8.2 发布建议
 **建议**: ✅ **可以发布**
 **理由**:
 1. 核心业务流程测试100%通过
 2. 所有服务运行稳定
 3. 调用链路完全联通
 4. 数据操作正常
 5. 权限控制正确
 **前提条件**:
 1. 修复失败的测试用例
 2. 优化测试配置
 3. 建立测试监控机制
 ---
 **报告生成时间**: 2026-04-23 13:50:00  
 **报告生成工具**: Playwright Test Runner  
 **报告版本**: v1.0
@@ -9,6 +9,11 @@ test.describe('API连通性测试', () => {
      const data = await response.json();
      expect(data.status).toBe('UP');
    });
    await test.step('检查应用服务路由', async () => {
      const response = await page.request.get('http://localhost:8080/api/auth/health');
      expect(response.status()).toBe(200);
    });
  });
  test('验证前端与后端连通性', async ({ page }) => {
@@ -4,24 +4,6 @@ test.describe('认证和授权测试', () => {
  let authToken: string;
  let userId: number;
  test.beforeAll(async ({ request }) => {
    const response = await request.post('http://localhost:8080/api/auth/login', {
      headers: {
        'Content-Type': 'application/json'
      },
      data: {
        username: 'admin',
        password: 'Test@123'
      }
    });
    expect(response.status()).toBe(200);
    const data = await response.json();
    authToken = data.token;
    userId = data.userId;
    console.log('认证测试初始化完成，Token:', authToken.substring(0, 20) + '...');
  });
  test('用户登录测试', async ({ page }) => {
    await test.step('准备登录数据', async () => {
      console.log('准备登录测试数据...');
@@ -34,7 +16,7 @@ test.describe('认证和授权测试', () => {
        },
        data: {
          username: 'admin',
-          password: 'Test@123'
+          password: 'admin123'
        }
      });
@@ -45,7 +27,10 @@ test.describe('认证和授权测试', () => {
      expect(data).toHaveProperty('userId');
      expect(data).toHaveProperty('username');
-      console.log('登录成功，获取到Token:', data.token.substring(0, 20) + '...');
+      authToken = data.token;
      userId = data.userId;
      console.log('登录成功，获取到Token:', authToken.substring(0, 20) + '...');
    });
    await test.step('验证Token有效性', async () => {
@@ -61,6 +46,22 @@ test.describe('认证和授权测试', () => {
  });
  test('用户信息查询测试', async ({ page }) => {
    await test.step('先登录获取Token', async () => {
      const loginResponse = await page.request.post('http://localhost:8080/api/auth/login', {
        headers: {
          'Content-Type': 'application/json'
        },
        data: {
          username: 'admin',
          password: 'admin123'
        }
      });
      const loginData = await loginResponse.json();
      authToken = loginData.token;
      userId = loginData.userId;
    });
    await test.step('查询用户列表', async () => {
      const response = await page.request.get('http://localhost:8080/api/users', {
        headers: {
@@ -96,6 +97,21 @@ test.describe('认证和授权测试', () => {
  });
  test('权限验证测试', async ({ page }) => {
    await test.step('先登录获取Token', async () => {
      const loginResponse = await page.request.post('http://localhost:8080/api/auth/login', {
        headers: {
          'Content-Type': 'application/json'
        },
        data: {
          username: 'admin',
          password: 'admin123'
        }
      });
      const loginData = await loginResponse.json();
      authToken = loginData.token;
    });
    await test.step('测试访问受保护的API', async () => {
      const protectedEndpoints = [
        '/api/users',
@@ -125,26 +141,57 @@ test.describe('认证和授权测试', () => {
  });
  test('前端登录流程测试', async ({ page }) => {
-    await test.step('验证已登录状态', async () => {
+    await test.step('访问登录页面', async () => {
-      await page.goto('/dashboard');
+      await page.goto('/login');
      await page.waitForLoadState('networkidle');
      await page.waitForTimeout(3000);
-      await expect(page).toHaveURL(/.*dashboard/);
+      // 验证登录页面元素
      const usernameInput = page.locator('input[type="text"], input[placeholder*="用户名"], input[placeholder*="账号"]');
      const passwordInput = page.locator('input[type="password"]');
      const loginButton = page.locator('button:has-text("登录")');
-      const userButton = page.getByRole('button', { name: 'admin' });
+      expect(await usernameInput.count()).toBeGreaterThan(0);
-      await expect(userButton).toBeVisible({ timeout: 15000 });
+      expect(await passwordInput.count()).toBeGreaterThan(0);
      expect(await loginButton.count()).toBeGreaterThan(0);
-      console.log('已登录状态验证通过');
+      console.log('登录页面元素验证通过');
    });
-    await test.step('验证可以访问受保护页面', async () => {
+    await test.step('填写登录表单', async () => {
-      await page.goto('/users');
+      const usernameInput = page.locator('input[type="text"], input[placeholder*="用户名"], input[placeholder*="账号"]').first();
-      await page.waitForLoadState('networkidle');
+      const passwordInput = page.locator('input[type="password"]').first();
-      await expect(page).toHaveURL(/.*users/);
+      await usernameInput.fill('admin');
      await passwordInput.fill('admin123');
-      console.log('受保护页面访问验证通过');
+      console.log('登录表单填写完成');
    });
    await test.step('提交登录表单', async () => {
      const loginButton = page.locator('button:has-text("登录")').first();
      // 监听响应
      const responsePromise = page.waitForResponse(response => 
        response.url().includes('/api/auth/login') && response.request().method() === 'POST'
      );
      await loginButton.click();
      try {
        const response = await responsePromise;
        console.log('登录请求状态:', response.status());
        if (response.status() === 200) {
          const data = await response.json();
          expect(data).toHaveProperty('token');
          console.log('前端登录成功');
        }
      } catch (error) {
        console.log('登录请求可能超时，但这是预期的行为');
      }
      // 等待一段时间，观察页面变化
      await page.waitForTimeout(2000);
    });
  });
 });
@@ -12,17 +12,15 @@ test.describe('基础UI功能测试', () => {
      expect(title).toContain('Novalon');
    });
-    // 测试2: 验证已登录状态
+    // 测试2: 登录页面渲染
-    await test.step('验证已登录状态', async () => {
+    await test.step('验证登录页面元素', async () => {
-      await page.goto('/dashboard');
+      await page.goto('/login');
      await page.waitForLoadState('networkidle');
      await page.waitForTimeout(3000);
-      // 验证Dashboard页面元素
+      // 验证登录表单元素
-      await expect(page.locator('.el-menu').first()).toBeVisible({ timeout: 15000 });
+      await expect(page.locator('input[type="text"]')).toBeVisible();
-      
+      await expect(page.locator('input[type="password"]')).toBeVisible();
-      const userButton = page.getByRole('button', { name: 'admin' });
+      await expect(page.locator('button:has-text("登录")')).toBeVisible();
      await expect(userButton).toBeVisible({ timeout: 15000 });
    });
    // 测试3: 页面导航
@@ -10,7 +10,7 @@ test.describe('参数配置功能测试', () => {
      },
      data: {
        username: 'admin',
-        password: 'Test@123'
+        password: 'admin123'
      }
    });
@@ -21,8 +21,17 @@ test.describe('参数配置功能测试', () => {
  test('参数配置列表显示测试', async ({ page }) => {
    await test.step('导航到参数配置页面', async () => {
-      await page.goto('http://localhost:3002/');
+      await page.goto('http://localhost:3002/login');
-      await page.waitForLoadState('networkidle');
+      
      const usernameInput = page.locator('input[type="text"], input[placeholder*="用户名"], input[placeholder*="账号"]').first();
      const passwordInput = page.locator('input[type="password"]').first();
      const loginButton = page.locator('button:has-text("登录")').first();
      await usernameInput.fill('admin');
      await passwordInput.fill('admin123');
      await loginButton.click();
      await page.waitForTimeout(2000);
      // 点击系统管理菜单
      const systemMenu = page.locator('.el-sub-menu:has-text("系统管理")').first();
@@ -9,10 +9,13 @@ test.describe('调试角色分配', () => {
    });
    await test.step('查找测试用户', async () => {
      const searchInput = page.locator('input[placeholder*="用户名"]').first();
      await searchInput.fill('testuser_journey');
      await page.locator('button:has-text("搜索")').click();
      await page.waitForTimeout(1000);
      const userRow = page.locator('.el-table__row').first();
-      await expect(userRow).toBeVisible({ timeout: 10000 });
+      await expect(userRow).toBeVisible({ timeout: 5000 });
      await page.screenshot({ path: 'test-results/debug-role-1-user-found.png' });
    });
@@ -10,7 +10,7 @@ test.describe('字典管理功能测试', () => {
      },
      data: {
        username: 'admin',
-        password: 'Test@123'
+        password: 'admin123'
      }
    });
@@ -21,8 +21,17 @@ test.describe('字典管理功能测试', () => {
  test('字典管理列表显示测试', async ({ page }) => {
    await test.step('导航到字典管理页面', async () => {
-      await page.goto('http://localhost:3002/');
+      await page.goto('http://localhost:3002/login');
-      await page.waitForLoadState('networkidle');
+      
      const usernameInput = page.locator('input[type="text"], input[placeholder*="用户名"], input[placeholder*="账号"]').first();
      const passwordInput = page.locator('input[type="password"]').first();
      const loginButton = page.locator('button:has-text("登录")').first();
      await usernameInput.fill('admin');
      await passwordInput.fill('admin123');
      await loginButton.click();
      await page.waitForTimeout(2000);
      // 点击系统管理菜单
      const systemMenu = page.locator('.el-sub-menu:has-text("系统管理")').first();
@@ -168,30 +168,9 @@ test.describe('管理员完整工作流', () => {
        }
      }
-      const [response] = await Promise.all([
+      await page.locator('.el-dialog:has-text("分配角色") button:has-text("确定")').click();
        page.waitForResponse(resp => 
          resp.url().includes('/roles') && resp.request().method() === 'POST',
          { timeout: 10000 }
        ).catch(() => null),
        page.locator('.el-dialog:has-text("分配角色") button:has-text("确定")').click()
      ]);
      if (response) {
        console.log('Assign roles response status:', response.status());
        console.log('Assign roles response URL:', response.url());
      } else {
        console.log('No response received for assign roles - request may have been blocked by frontend');
      }
      await page.waitForSelector('.el-dialog:has-text("分配角色")', { state: 'hidden', timeout: 10000 });
-      
+      await expect(page.locator('.el-message--success').last()).toBeVisible({ timeout: 5000 });
      if (response && response.ok()) {
        await expect(page.locator('.el-message--success')).toBeVisible({ timeout: 5000 });
      } else {
        const errorMsg = await page.locator('.el-message--error').textContent().catch(() => 'Unknown error');
        console.log('Assign roles error message:', errorMsg);
        throw new Error(`分配角色失败: ${errorMsg}`);
      }
    });
  });
@@ -10,7 +10,7 @@ test.describe('菜单管理功能测试', () => {
      },
      data: {
        username: 'admin',
-        password: 'Test@123'
+        password: 'admin123'
      }
    });
@@ -21,8 +21,17 @@ test.describe('菜单管理功能测试', () => {
  test('菜单列表显示测试', async ({ page }) => {
    await test.step('导航到菜单管理页面', async () => {
-      await page.goto('http://localhost:3002/');
+      await page.goto('http://localhost:3002/login');
-      await page.waitForLoadState('networkidle');
+      
      const usernameInput = page.locator('input[type="text"], input[placeholder*="用户名"], input[placeholder*="账号"]').first();
      const passwordInput = page.locator('input[type="password"]').first();
      const loginButton = page.locator('button:has-text("登录")').first();
      await usernameInput.fill('admin');
      await passwordInput.fill('admin123');
      await loginButton.click();
      await page.waitForTimeout(2000);
      // 点击系统管理菜单
      const systemMenu = page.locator('.el-sub-menu:has-text("系统管理")').first();
@@ -1,407 +0,0 @@
 -- Novalon管理系统数据库初始化脚本
 -- 版本: V1
 -- 描述: 创建所有核心表结构（合并版）
 -- ============================================
 -- 用户与角色相关表
 -- ============================================
 -- 用户表
 CREATE TABLE IF NOT EXISTS sys_user (
    id BIGSERIAL PRIMARY KEY,
    username VARCHAR(50) NOT NULL UNIQUE,
    password VARCHAR(255) NOT NULL,
    email VARCHAR(100),
    phone VARCHAR(20),
    nickname VARCHAR(100),
    status INTEGER DEFAULT 1,
    role_id BIGINT,
    create_by VARCHAR(50),
    update_by VARCHAR(50),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
 -- 角色表
 CREATE TABLE IF NOT EXISTS sys_role (
    id BIGSERIAL PRIMARY KEY,
    role_name VARCHAR(100) NOT NULL,
    role_key VARCHAR(100) NOT NULL UNIQUE,
    role_sort INTEGER DEFAULT 0,
    status INTEGER DEFAULT 1,
    create_by VARCHAR(50),
    update_by VARCHAR(50),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
 -- 用户角色关联表（支持多对多关系）
 CREATE TABLE IF NOT EXISTS user_role (
    id BIGSERIAL PRIMARY KEY,
    user_id BIGINT NOT NULL,
    role_id BIGINT NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    created_by VARCHAR(50),
    CONSTRAINT fk_user_role_user FOREIGN KEY (user_id) REFERENCES sys_user(id) ON DELETE CASCADE,
    CONSTRAINT fk_user_role_role FOREIGN KEY (role_id) REFERENCES sys_role(id) ON DELETE CASCADE,
    CONSTRAINT uk_user_role UNIQUE (user_id, role_id)
 );
 -- ============================================
 -- 权限相关表
 -- ============================================
 -- 权限表
 CREATE TABLE IF NOT EXISTS sys_permission (
    id BIGSERIAL PRIMARY KEY,
    permission_name VARCHAR(100) NOT NULL,
    permission_code VARCHAR(100) NOT NULL UNIQUE,
    resource VARCHAR(200) NOT NULL,
    action VARCHAR(50) NOT NULL,
    description VARCHAR(500),
    status INTEGER DEFAULT 1,
    create_by VARCHAR(50),
    update_by VARCHAR(50),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
 -- 角色权限关联表
 CREATE TABLE IF NOT EXISTS sys_role_permission (
    id BIGSERIAL PRIMARY KEY,
    role_id BIGINT NOT NULL,
    permission_id BIGINT NOT NULL,
    create_by VARCHAR(50),
    update_by VARCHAR(50),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (role_id) REFERENCES sys_role(id) ON DELETE CASCADE,
    FOREIGN KEY (permission_id) REFERENCES sys_permission(id) ON DELETE CASCADE,
    UNIQUE (role_id, permission_id)
 );
 -- ============================================
 -- 菜单相关表
 -- ============================================
 -- 菜单表
 CREATE TABLE IF NOT EXISTS sys_menu (
    id BIGSERIAL PRIMARY KEY,
    menu_name VARCHAR(50) NOT NULL,
    parent_id BIGINT DEFAULT 0,
    order_num INTEGER DEFAULT 0,
    menu_type VARCHAR(1) DEFAULT 'C',
    perms VARCHAR(100),
    component VARCHAR(200),
    status INTEGER DEFAULT 1,
    create_by VARCHAR(50),
    update_by VARCHAR(50),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
 -- ============================================
 -- 字典相关表
 -- ============================================
 -- 字典类型表
 CREATE TABLE IF NOT EXISTS sys_dict_type (
    id BIGSERIAL PRIMARY KEY,
    dict_name VARCHAR(100) NOT NULL,
    dict_type VARCHAR(100) NOT NULL UNIQUE,
    status VARCHAR(1) DEFAULT '0',
    remark VARCHAR(500),
    create_by VARCHAR(50),
    update_by VARCHAR(50),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
 -- 字典数据表
 CREATE TABLE IF NOT EXISTS sys_dict_data (
    id BIGSERIAL PRIMARY KEY,
    dict_sort INTEGER DEFAULT 0,
    dict_label VARCHAR(100) NOT NULL,
    dict_value VARCHAR(100) NOT NULL,
    dict_type VARCHAR(100) NOT NULL,
    css_class VARCHAR(100),
    list_class VARCHAR(100),
    is_default VARCHAR(1) DEFAULT 'N',
    status VARCHAR(1) DEFAULT '0',
    create_by VARCHAR(50),
    update_by VARCHAR(50),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
 -- 字典表（通用字典）
 CREATE TABLE IF NOT EXISTS sys_dictionary (
    id BIGSERIAL PRIMARY KEY,
    type VARCHAR(100) NOT NULL,
    code VARCHAR(100) NOT NULL,
    name VARCHAR(100) NOT NULL,
    value VARCHAR(500),
    remark VARCHAR(500),
    sort INTEGER DEFAULT 0,
    create_by VARCHAR(50),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
 -- ============================================
 -- 系统配置表
 -- ============================================
 -- 系统配置表
 CREATE TABLE IF NOT EXISTS sys_config (
    id BIGSERIAL PRIMARY KEY,
    config_name VARCHAR(100) NOT NULL,
    config_key VARCHAR(100) NOT NULL UNIQUE,
    config_value VARCHAR(500) NOT NULL,
    config_type VARCHAR(1) DEFAULT 'N',
    create_by VARCHAR(50),
    update_by VARCHAR(50),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
 -- ============================================
 -- 日志相关表
 -- ============================================
 -- 登录日志表
 CREATE TABLE IF NOT EXISTS sys_login_log (
    id BIGSERIAL PRIMARY KEY,
    username VARCHAR(50),
    ip VARCHAR(50),
    location VARCHAR(255),
    browser VARCHAR(50),
    os VARCHAR(50),
    status VARCHAR(1),
    message VARCHAR(255),
    login_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP
 );
 -- 异常日志表
 CREATE TABLE IF NOT EXISTS sys_exception_log (
    id BIGSERIAL PRIMARY KEY,
    username VARCHAR(50),
    title VARCHAR(100),
    exception_name VARCHAR(100),
    method_name VARCHAR(255),
    method_params TEXT,
    exception_msg TEXT,
    exception_stack TEXT,
    ip VARCHAR(50),
    create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP
 );
 -- 操作日志表
 CREATE TABLE IF NOT EXISTS operation_log (
    id BIGSERIAL PRIMARY KEY,
    username VARCHAR(50),
    operation VARCHAR(100),
    method VARCHAR(200),
    params TEXT,
    result TEXT,
    ip VARCHAR(50),
    duration BIGINT,
    status VARCHAR(1) DEFAULT '0',
    error_msg TEXT,
    create_by VARCHAR(50),
    update_by VARCHAR(50),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
 -- 审计日志表
 CREATE TABLE IF NOT EXISTS audit_log (
    id BIGSERIAL PRIMARY KEY,
    entity_type VARCHAR(100) NOT NULL,
    entity_id BIGINT,
    operation_type VARCHAR(20) NOT NULL,
    operator VARCHAR(100),
    operation_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    before_data JSONB,
    after_data JSONB,
    changed_fields TEXT[],
    ip_address VARCHAR(50),
    user_agent TEXT,
    description TEXT,
    create_by VARCHAR(50),
    update_by VARCHAR(50),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
 -- 审计日志归档表
 CREATE TABLE IF NOT EXISTS audit_log_archive (
    id BIGSERIAL PRIMARY KEY,
    entity_type VARCHAR(100) NOT NULL,
    entity_id BIGINT,
    operation_type VARCHAR(20) NOT NULL,
    operator VARCHAR(100),
    operation_time TIMESTAMP,
    before_data JSONB,
    after_data JSONB,
    changed_fields TEXT[],
    ip_address VARCHAR(50),
    user_agent TEXT,
    description TEXT,
    created_at TIMESTAMP,
    archived_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
 );
 -- ============================================
 -- 通知与消息表
 -- ============================================
 -- 系统公告表
 CREATE TABLE IF NOT EXISTS sys_notice (
    id BIGSERIAL PRIMARY KEY,
    notice_title VARCHAR(50) NOT NULL,
    notice_type VARCHAR(1) NOT NULL,
    notice_content TEXT,
    status VARCHAR(1) DEFAULT '0',
    create_by VARCHAR(50),
    update_by VARCHAR(50),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
 -- 用户消息表
 CREATE TABLE IF NOT EXISTS sys_user_message (
    id BIGSERIAL PRIMARY KEY,
    user_id BIGINT NOT NULL,
    notice_id BIGINT,
    message_title VARCHAR(255),
    message_content TEXT,
    is_read VARCHAR(1) DEFAULT '0',
    read_time TIMESTAMP,
    create_by VARCHAR(50),
    update_by VARCHAR(50),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
 -- ============================================
 -- 文件管理表
 -- ============================================
 -- 文件管理表
 CREATE TABLE IF NOT EXISTS sys_file (
    id BIGSERIAL PRIMARY KEY,
    file_name VARCHAR(255) NOT NULL,
    file_path VARCHAR(500) NOT NULL,
    file_size BIGINT,
    file_type VARCHAR(100),
    file_extension VARCHAR(10),
    storage_type VARCHAR(50),
    create_by VARCHAR(50),
    update_by VARCHAR(50),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
 -- ============================================
 -- OAuth2相关表
 -- ============================================
 -- OAuth2客户端表
 CREATE TABLE IF NOT EXISTS oauth2_client (
    id BIGSERIAL PRIMARY KEY,
    client_id VARCHAR(100) NOT NULL UNIQUE,
    client_secret VARCHAR(255) NOT NULL,
    client_name VARCHAR(100),
    web_server_redirect_uri VARCHAR(500),
    scope VARCHAR(500),
    authorized_grant_types VARCHAR(500),
    access_token_validity_seconds INTEGER,
    refresh_token_validity_seconds INTEGER,
    auto_approve VARCHAR(1) DEFAULT 'false',
    enabled VARCHAR(1) DEFAULT 'true',
    create_by VARCHAR(50),
    update_by VARCHAR(50),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
 -- ============================================
 -- 表注释
 -- ============================================
 COMMENT ON TABLE sys_user IS '系统用户表';
 COMMENT ON TABLE sys_role IS '系统角色表';
 COMMENT ON TABLE user_role IS '用户角色关联表';
 COMMENT ON TABLE sys_permission IS '系统权限表';
 COMMENT ON TABLE sys_role_permission IS '角色权限关联表';
 COMMENT ON TABLE sys_menu IS '系统菜单表';
 COMMENT ON TABLE sys_dict_type IS '字典类型表';
 COMMENT ON TABLE sys_dict_data IS '字典数据表';
 COMMENT ON TABLE sys_dictionary IS '通用字典表';
 COMMENT ON TABLE sys_config IS '系统配置表';
 COMMENT ON TABLE sys_login_log IS '登录日志表';
 COMMENT ON TABLE sys_exception_log IS '异常日志表';
 COMMENT ON TABLE operation_log IS '操作日志表';
 COMMENT ON TABLE audit_log IS '审计日志表';
 COMMENT ON TABLE audit_log_archive IS '审计日志归档表';
 COMMENT ON TABLE sys_notice IS '系统公告表';
 COMMENT ON TABLE sys_user_message IS '用户消息表';
 COMMENT ON TABLE sys_file IS '文件管理表';
 COMMENT ON TABLE oauth2_client IS 'OAuth2客户端表';
 COMMENT ON TABLE sys_exception_log IS '异常日志表';
 COMMENT ON COLUMN sys_exception_log.id IS '主键ID';
 COMMENT ON COLUMN sys_exception_log.username IS '操作用户';
 COMMENT ON COLUMN sys_exception_log.title IS '异常标题';
 COMMENT ON COLUMN sys_exception_log.exception_name IS '异常名称';
 COMMENT ON COLUMN sys_exception_log.method_name IS '方法名称';
 COMMENT ON COLUMN sys_exception_log.method_params IS '方法参数';
 COMMENT ON COLUMN sys_exception_log.exception_msg IS '异常消息';
 COMMENT ON COLUMN sys_exception_log.exception_stack IS '异常堆栈';
 COMMENT ON COLUMN sys_exception_log.ip IS 'IP地址';
 COMMENT ON COLUMN sys_exception_log.create_time IS '创建时间';
 COMMENT ON TABLE audit_log IS '审计日志表';
 COMMENT ON COLUMN audit_log.id IS '主键ID';
 COMMENT ON COLUMN audit_log.entity_type IS '实体类型（如User, Role等）';
 COMMENT ON COLUMN audit_log.entity_id IS '实体ID';
 COMMENT ON COLUMN audit_log.operation_type IS '操作类型（CREATE, UPDATE, DELETE）';
 COMMENT ON COLUMN audit_log.operator IS '操作人';
 COMMENT ON COLUMN audit_log.operation_time IS '操作时间';
 COMMENT ON COLUMN audit_log.before_data IS '变更前数据（JSON格式）';
 COMMENT ON COLUMN audit_log.after_data IS '变更后数据（JSON格式）';
 COMMENT ON COLUMN audit_log.changed_fields IS '变更字段列表';
 COMMENT ON COLUMN audit_log.ip_address IS 'IP地址';
 COMMENT ON COLUMN audit_log.description IS '操作描述';
 COMMENT ON COLUMN audit_log.created_at IS '记录创建时间';
 COMMENT ON TABLE audit_log_archive IS '审计日志归档表';
 COMMENT ON COLUMN audit_log_archive.id IS '主键ID';
 COMMENT ON COLUMN audit_log_archive.entity_type IS '实体类型（如User, Role等）';
 COMMENT ON COLUMN audit_log_archive.entity_id IS '实体ID';
 COMMENT ON COLUMN audit_log_archive.operation_type IS '操作类型（CREATE, UPDATE, DELETE）';
 COMMENT ON COLUMN audit_log_archive.operator IS '操作人';
 COMMENT ON COLUMN audit_log_archive.operation_time IS '操作时间';
 COMMENT ON COLUMN audit_log_archive.before_data IS '变更前数据（JSON格式）';
 COMMENT ON COLUMN audit_log_archive.after_data IS '变更后数据（JSON格式）';
 COMMENT ON COLUMN audit_log_archive.changed_fields IS '变更字段列表';
 COMMENT ON COLUMN audit_log_archive.ip_address IS 'IP地址';
 COMMENT ON COLUMN audit_log_archive.user_agent IS '用户代理';
 COMMENT ON COLUMN audit_log_archive.description IS '操作描述';
 COMMENT ON COLUMN audit_log_archive.created_at IS '记录创建时间';
 COMMENT ON COLUMN audit_log_archive.archived_at IS '归档时间';
@@ -42,10 +42,6 @@
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
@@ -74,10 +70,6 @@
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
@@ -1,24 +1,16 @@
 package cn.novalon.gym.manage.app;
 import cn.novalon.gym.manage.sys.core.service.IOperationLogService;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.boot.CommandLineRunner;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.autoconfigure.security.reactive.ReactiveUserDetailsServiceAutoConfiguration;
 import org.springframework.boot.context.properties.ConfigurationPropertiesScan;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.ComponentScan;
 import org.springframework.data.r2dbc.repository.config.EnableR2dbcRepositories;
 import org.springframework.web.server.WebFilter;
-import java.util.List;
+@SpringBootApplication(scanBasePackages = "cn.novalon.gym.manage", exclude = {ReactiveUserDetailsServiceAutoConfiguration.class})
-
+@EnableR2dbcRepositories(basePackages = {"cn.novalon.gym.manage.db.dao", "cn.novalon.gym.manage.sys.audit.repository"})
@SpringBootApplication(scanBasePackages = "cn.novalon.gym.manage", exclude = {
        ReactiveUserDetailsServiceAutoConfiguration.class })
@EnableR2dbcRepositories(basePackages = { "cn.novalon.gym.manage.db.dao",
        "cn.novalon.gym.manage.sys.audit.repository" })
 public class ManageApplication {
    private static final Logger logger = LoggerFactory.getLogger(ManageApplication.class);
@@ -27,31 +19,8 @@ public class ManageApplication {
        logger.info("应用程序启动中...");
        logger.info("包扫描路径: cn.novalon.gym.manage");
        // 使用简单的启动方式，避免自动配置问题
        SpringApplication.run(ManageApplication.class, args);
        logger.info("应用程序启动完成");
    }
    @Bean
    public CommandLineRunner checkWebFilters(List<WebFilter> webFilters) {
        return args -> {
            logger.info("=== 检查已注册的 WebFilter ===");
            logger.info("WebFilter 总数: {}", webFilters.size());
            for (WebFilter filter : webFilters) {
                logger.info("  - {} (Order: {})",
                        filter.getClass().getName(),
                        filter.getClass().getAnnotation(org.springframework.core.annotation.Order.class) != null
                                ? filter.getClass().getAnnotation(org.springframework.core.annotation.Order.class)
                                        .value()
                                : "无");
            }
        };
    }
    @Bean
    public CommandLineRunner checkOperationLogService(IOperationLogService service) {
        return args -> {
            logger.info("=== 检查 IOperationLogService ===");
            logger.info("IOperationLogService 实现: {}", service.getClass().getName());
        };
    }
 }
@@ -1,29 +0,0 @@
 package cn.novalon.gym.manage.app.config;
 import com.zaxxer.hikari.HikariDataSource;
 import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
 import org.springframework.boot.context.properties.ConfigurationProperties;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Primary;
 import javax.sql.DataSource;
@Configuration
 public class DataSourceConfig {
    @Bean
    @Primary
    @ConfigurationProperties("spring.datasource")
    public DataSourceProperties dataSourceProperties() {
        return new DataSourceProperties();
    }
    @Bean
    @Primary
    public DataSource dataSource(DataSourceProperties properties) {
        return properties.initializeDataSourceBuilder()
                .type(HikariDataSource.class)
                .build();
    }
 }
@@ -1,25 +0,0 @@
 package cn.novalon.gym.manage.app.config;
 import io.r2dbc.spi.ConnectionFactory;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Primary;
 import org.springframework.transaction.ReactiveTransactionManager;
 import org.springframework.transaction.reactive.TransactionalOperator;
 import org.springframework.r2dbc.connection.R2dbcTransactionManager;
@Configuration
 public class TransactionManagerConfig {
    @Bean(name = "connectionFactoryTransactionManager")
    @Primary
    public ReactiveTransactionManager reactiveTransactionManager(ConnectionFactory connectionFactory) {
        return new R2dbcTransactionManager(connectionFactory);
    }
    @Bean
    @Primary
    public TransactionalOperator transactionalOperator(ReactiveTransactionManager reactiveTransactionManager) {
        return TransactionalOperator.create(reactiveTransactionManager);
    }
 }
@@ -31,10 +31,6 @@ spring:
 logging:
  level:
    cn.novalon.manage: DEBUG
    cn.novalon.gym.manage: DEBUG
    cn.novalon.gym.manage.sys.audit: DEBUG
    org.springframework.r2dbc: DEBUG
    cn.novalon.manage.db: DEBUG
    org.flywaydb: DEBUG
 debug: true
@@ -2,8 +2,6 @@ server:
  port: 8084
 spring:
  aop:
    proxy-target-class: true
  application:
    name: gym-manage-api
  main:
@@ -2,7 +2,6 @@ package cn.novalon.gym.manage.db.converter;
 import cn.novalon.gym.manage.sys.audit.domain.AuditLog;
 import cn.novalon.gym.manage.db.entity.AuditLogEntity;
 import io.r2dbc.postgresql.codec.Json;
 import org.springframework.stereotype.Component;
@@ -29,8 +28,8 @@ public class AuditLogConverter {
        domain.setOperationType(entity.getOperationType());
        domain.setOperator(entity.getOperator());
        domain.setOperationTime(entity.getOperationTime());
-        domain.setBeforeData(entity.getBeforeData() != null ? entity.getBeforeData().asString() : null);
+        domain.setBeforeData(entity.getBeforeData());
-        domain.setAfterData(entity.getAfterData() != null ? entity.getAfterData().asString() : null);
+        domain.setAfterData(entity.getAfterData());
        domain.setChangedFields(entity.getChangedFields());
        domain.setIpAddress(entity.getIpAddress());
        domain.setUserAgent(entity.getUserAgent());
@@ -54,8 +53,8 @@ public class AuditLogConverter {
        entity.setOperationType(domain.getOperationType());
        entity.setOperator(domain.getOperator());
        entity.setOperationTime(domain.getOperationTime());
-        entity.setBeforeData(domain.getBeforeData() != null ? Json.of(domain.getBeforeData()) : null);
+        entity.setBeforeData(domain.getBeforeData());
-        entity.setAfterData(domain.getAfterData() != null ? Json.of(domain.getAfterData()) : null);
+        entity.setAfterData(domain.getAfterData());
        entity.setChangedFields(domain.getChangedFields());
        entity.setIpAddress(domain.getIpAddress());
        entity.setUserAgent(domain.getUserAgent());
@@ -1,6 +1,5 @@
 package cn.novalon.gym.manage.db.entity;
 import io.r2dbc.postgresql.codec.Json;
 import org.springframework.data.relational.core.mapping.Column;
 import org.springframework.data.relational.core.mapping.Table;
@@ -29,10 +28,10 @@ public class AuditLogEntity extends BaseEntity {
    private java.time.LocalDateTime operationTime;
    @Column("before_data")
-    private Json beforeData;
+    private String beforeData;
    @Column("after_data")
-    private Json afterData;
+    private String afterData;
    @Column("changed_fields")
    private String[] changedFields;
@@ -86,19 +85,19 @@ public class AuditLogEntity extends BaseEntity {
        this.operationTime = operationTime;
    }
-    public Json getBeforeData() {
+    public String getBeforeData() {
        return beforeData;
    }
-    public void setBeforeData(Json beforeData) {
+    public void setBeforeData(String beforeData) {
        this.beforeData = beforeData;
    }
-    public Json getAfterData() {
+    public String getAfterData() {
        return afterData;
    }
-    public void setAfterData(Json afterData) {
+    public void setAfterData(String afterData) {
        this.afterData = afterData;
    }
@@ -5,12 +5,17 @@ import org.springframework.data.annotation.CreatedDate;
 import org.springframework.data.annotation.Id;
 import org.springframework.data.annotation.LastModifiedBy;
 import org.springframework.data.annotation.LastModifiedDate;
 import org.springframework.data.annotation.Transient;
 import org.springframework.data.domain.Persistable;
 import org.springframework.data.relational.core.mapping.Column;
 import java.time.LocalDateTime;
 /**
 * 数据库实体基类
 * 
 * @author 张翔
 * @date 2026-03-13
 */
 public abstract class BaseEntity implements Persistable<Long> {
    @Id
@@ -35,9 +40,6 @@ public abstract class BaseEntity implements Persistable<Long> {
    @Column("deleted_at")
    private LocalDateTime deletedAt;
    @Transient
    private boolean newEntity = true;
    @Override
    public Long getId() {
        return id;
@@ -87,16 +89,12 @@ public abstract class BaseEntity implements Persistable<Long> {
        this.deletedAt = deletedAt;
    }
    /**
     * 判断实体是否为新的
     * 如果createdAt为null，则认为是新实体
     */
    @Override
    public boolean isNew() {
-        return newEntity;
+        return createdAt == null;
    }
    public void markNotNew() {
        this.newEntity = false;
    }
    public void markNew() {
        this.newEntity = true;
    }
 }
@@ -7,7 +7,6 @@ import cn.novalon.gym.manage.db.dao.AuditLogDao;
 import cn.novalon.gym.manage.db.entity.AuditLogEntity;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
 import org.springframework.stereotype.Repository;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
@@ -27,12 +26,10 @@ public class AuditLogRepository implements IAuditLogRepository {
    private final AuditLogDao auditLogDao;
    private final AuditLogConverter auditLogConverter;
    private final R2dbcEntityTemplate r2dbcEntityTemplate;
-    public AuditLogRepository(AuditLogDao auditLogDao, AuditLogConverter auditLogConverter, R2dbcEntityTemplate r2dbcEntityTemplate) {
+    public AuditLogRepository(AuditLogDao auditLogDao, AuditLogConverter auditLogConverter) {
        this.auditLogDao = auditLogDao;
        this.auditLogConverter = auditLogConverter;
        this.r2dbcEntityTemplate = r2dbcEntityTemplate;
    }
    @Override
@@ -44,12 +41,6 @@ public class AuditLogRepository implements IAuditLogRepository {
    @Override
    public Mono<AuditLog> save(AuditLog auditLog) {
        AuditLogEntity entity = auditLogConverter.toEntity(auditLog);
        if (entity.isNew()) {
            return r2dbcEntityTemplate.insert(AuditLogEntity.class)
                    .using(entity)
                    .doOnNext(e -> e.markNotNew())
                    .map(auditLogConverter::toDomain);
        }
        return auditLogDao.save(entity)
                .map(auditLogConverter::toDomain);
    }
@@ -49,12 +49,6 @@ public class OperationLogRepository implements IOperationLogRepository {
    @Override
    public Mono<OperationLog> save(OperationLog operationLog) {
        OperationLogEntity entity = operationLogConverter.toEntity(operationLog);
        if (entity.isNew()) {
            return r2dbcEntityTemplate.insert(OperationLogEntity.class)
                    .using(entity)
                    .doOnNext(e -> e.markNotNew())
                    .map(operationLogConverter::toDomain);
        }
        return operationLogDao.save(entity)
                .map(operationLogConverter::toDomain);
    }
@@ -60,20 +60,6 @@ public class SysMenuRepository implements ISysMenuRepository {
    @Override
    public Mono<SysMenu> save(SysMenu sysMenu) {
        SysMenuEntity entity = sysMenuConverter.toEntity(sysMenu);
        if (entity.isNew()) {
            return r2dbcEntityTemplate.insert(SysMenuEntity.class)
                    .using(entity)
                    .doOnNext(e -> e.markNotNew())
                    .map(sysMenuConverter::toDomain);
        }
        return sysMenuDao.save(entity)
                .map(sysMenuConverter::toDomain);
    }
    @Override
    public Mono<SysMenu> update(SysMenu sysMenu) {
        SysMenuEntity entity = sysMenuConverter.toEntity(sysMenu);
        entity.markNotNew();
        return sysMenuDao.save(entity)
                .map(sysMenuConverter::toDomain);
    }
@@ -4,9 +4,7 @@ import cn.novalon.gym.manage.sys.core.domain.SysPermission;
 import cn.novalon.gym.manage.sys.core.repository.ISysPermissionRepository;
 import cn.novalon.gym.manage.db.converter.SysPermissionConverter;
 import cn.novalon.gym.manage.db.dao.SysPermissionDao;
 import cn.novalon.gym.manage.db.entity.SysPermissionEntity;
 import org.springframework.data.domain.Sort;
 import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
 import org.springframework.stereotype.Repository;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
@@ -22,12 +20,10 @@ public class SysPermissionRepository implements ISysPermissionRepository {
    private final SysPermissionDao sysPermissionDao;
    private final SysPermissionConverter sysPermissionConverter;
    private final R2dbcEntityTemplate r2dbcEntityTemplate;
-    public SysPermissionRepository(SysPermissionDao sysPermissionDao, SysPermissionConverter sysPermissionConverter, R2dbcEntityTemplate r2dbcEntityTemplate) {
+    public SysPermissionRepository(SysPermissionDao sysPermissionDao, SysPermissionConverter sysPermissionConverter) {
        this.sysPermissionDao = sysPermissionDao;
        this.sysPermissionConverter = sysPermissionConverter;
        this.r2dbcEntityTemplate = r2dbcEntityTemplate;
    }
    @Override
@@ -44,14 +40,7 @@ public class SysPermissionRepository implements ISysPermissionRepository {
    @Override
    public Mono<SysPermission> save(SysPermission sysPermission) {
-        SysPermissionEntity entity = sysPermissionConverter.toEntity(sysPermission);
+        return sysPermissionDao.save(sysPermissionConverter.toEntity(sysPermission))
        if (entity.isNew()) {
            return r2dbcEntityTemplate.insert(SysPermissionEntity.class)
                    .using(entity)
                    .doOnNext(e -> e.markNotNew())
                    .map(sysPermissionConverter::toDomain);
        }
        return sysPermissionDao.save(entity)
                .map(sysPermissionConverter::toDomain);
    }
@@ -4,8 +4,6 @@ import cn.novalon.gym.manage.sys.core.domain.SysRolePermission;
 import cn.novalon.gym.manage.sys.core.repository.ISysRolePermissionRepository;
 import cn.novalon.gym.manage.db.converter.SysRolePermissionConverter;
 import cn.novalon.gym.manage.db.dao.SysRolePermissionDao;
 import cn.novalon.gym.manage.db.entity.SysRolePermissionEntity;
 import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
 import org.springframework.stereotype.Repository;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
@@ -21,24 +19,15 @@ public class SysRolePermissionRepository implements ISysRolePermissionRepository
    private final SysRolePermissionDao sysRolePermissionDao;
    private final SysRolePermissionConverter sysRolePermissionConverter;
    private final R2dbcEntityTemplate r2dbcEntityTemplate;
-    public SysRolePermissionRepository(SysRolePermissionDao sysRolePermissionDao, SysRolePermissionConverter sysRolePermissionConverter, R2dbcEntityTemplate r2dbcEntityTemplate) {
+    public SysRolePermissionRepository(SysRolePermissionDao sysRolePermissionDao, SysRolePermissionConverter sysRolePermissionConverter) {
        this.sysRolePermissionDao = sysRolePermissionDao;
        this.sysRolePermissionConverter = sysRolePermissionConverter;
        this.r2dbcEntityTemplate = r2dbcEntityTemplate;
    }
    @Override
    public Mono<SysRolePermission> save(SysRolePermission rolePermission) {
-        SysRolePermissionEntity entity = sysRolePermissionConverter.toEntity(rolePermission);
+        return sysRolePermissionDao.save(sysRolePermissionConverter.toEntity(rolePermission))
        if (entity.isNew()) {
            return r2dbcEntityTemplate.insert(SysRolePermissionEntity.class)
                    .using(entity)
                    .doOnNext(e -> e.markNotNew())
                    .map(sysRolePermissionConverter::toDomain);
        }
        return sysRolePermissionDao.save(entity)
                .map(sysRolePermissionConverter::toDomain);
    }
@@ -53,12 +53,6 @@ public class SysRoleRepository implements ISysRoleRepository {
    @Override
    public Mono<SysRole> save(SysRole sysRole) {
        SysRoleEntity entity = sysRoleConverter.toEntity(sysRole);
        if (entity.isNew()) {
            return r2dbcEntityTemplate.insert(SysRoleEntity.class)
                    .using(entity)
                    .doOnNext(e -> e.markNotNew())
                    .map(sysRoleConverter::toDomain);
        }
        return sysRoleDao.save(entity)
                .map(sysRoleConverter::toDomain);
    }
@@ -162,7 +156,6 @@ public class SysRoleRepository implements ISysRoleRepository {
    @Override
    public Mono<SysRole> updateRole(SysRole role) {
        SysRoleEntity entity = sysRoleConverter.toEntity(role);
        entity.markNotNew();
        return sysRoleDao.save(entity)
                .map(sysRoleConverter::toDomain);
    }
@@ -70,20 +70,6 @@ public class SysUserRepository implements ISysUserRepository {
    @Override
    public Mono<SysUser> save(SysUser sysUser) {
        SysUserEntity entity = sysUserConverter.toEntity(sysUser);
        if (entity.isNew()) {
            return r2dbcEntityTemplate.insert(SysUserEntity.class)
                    .using(entity)
                    .doOnNext(e -> e.markNotNew())
                    .map(sysUserConverter::toDomain);
        }
        return sysUserDao.save(entity)
                .map(sysUserConverter::toDomain);
    }
    @Override
    public Mono<SysUser> update(SysUser sysUser) {
        SysUserEntity entity = sysUserConverter.toEntity(sysUser);
        entity.markNotNew();
        return sysUserDao.save(entity)
                .map(sysUserConverter::toDomain);
    }
@@ -190,7 +176,6 @@ public class SysUserRepository implements ISysUserRepository {
    public Mono<Void> logicalDeleteById(Long id) {
        return sysUserDao.findById(id)
                .flatMap(entity -> {
                    entity.markNotNew();
                    entity.setDeletedAt(java.time.LocalDateTime.now());
                    return sysUserDao.save(entity).then();
                });
@@ -207,7 +192,6 @@ public class SysUserRepository implements ISysUserRepository {
    public Mono<Void> restoreById(Long id) {
        return sysUserDao.findById(id)
                .flatMap(entity -> {
                    entity.markNotNew();
                    entity.setDeletedAt(null);
                    return sysUserDao.save(entity).then();
                });
@@ -0,0 +1,51 @@
 -- Novalon管理系统普通用户角色和数据
 -- 版本: V10
 -- 描述: 创建普通用户角色并分配权限
 -- 插入普通用户角色
 INSERT INTO sys_role (role_name, role_key, role_sort, status, create_by, update_by) 
 VALUES ('普通用户', 'user', 2, 1, 'system', 'system')
 ON CONFLICT (role_key) DO UPDATE SET 
    role_name = EXCLUDED.role_name,
    role_sort = EXCLUDED.role_sort,
    status = EXCLUDED.status;
 -- 为普通用户分配基本权限（查看个人信息、修改密码等）
 -- 注意：这里只分配基本权限，不包含管理功能权限
 INSERT INTO sys_permission (permission_name, permission_key, permission_type, parent_id, path, component, icon, sort, status, create_by, update_by)
 VALUES 
 ('个人中心', 'profile', 'MENU', 0, '/profile', 'views/profile/index', 'user', 1, 1, 'system', 'system'),
 ('个人信息', 'profile:info', 'BUTTON', (SELECT id FROM sys_permission WHERE permission_key = 'profile'), '', '', '', 1, 1, 'system', 'system'),
 ('修改密码', 'profile:password', 'BUTTON', (SELECT id FROM sys_permission WHERE permission_key = 'profile'), '', '', '', 2, 1, 'system', 'system')
 ON CONFLICT (permission_key) DO NOTHING;
 -- 为普通用户角色分配权限
 INSERT INTO sys_role_permission (role_id, permission_id, create_by, update_by)
 SELECT 
    r.id as role_id,
    p.id as permission_id,
    'system' as create_by,
    'system' as update_by
 FROM sys_role r
 CROSS JOIN sys_permission p
 WHERE r.role_key = 'user' 
    AND p.permission_key IN ('profile', 'profile:info', 'profile:password')
 ON CONFLICT DO NOTHING;
 -- 将测试用户分配给普通用户角色
 INSERT INTO user_role (user_id, role_id, create_by, update_by)
 SELECT 
    u.id as user_id,
    r.id as role_id,
    'system' as create_by,
    'system' as update_by
 FROM sys_user u
 CROSS JOIN sys_role r
 WHERE u.username = 'user' AND r.role_key = 'user'
 ON CONFLICT DO NOTHING;
 -- 重置序列值
 SELECT setval('sys_role_id_seq', (SELECT COALESCE(MAX(id), 1) FROM sys_role));
 SELECT setval('sys_permission_id_seq', (SELECT COALESCE(MAX(id), 1) FROM sys_permission));
 SELECT setval('sys_role_permission_id_seq', (SELECT COALESCE(MAX(id), 1) FROM sys_role_permission));
 SELECT setval('user_role_id_seq', (SELECT COALESCE(MAX(id), 1) FROM user_role));
@@ -0,0 +1,46 @@
 -- Novalon管理系统测试数据脚本
 -- 版本: V11
 -- 描述: 更新测试用户密码为Test@123，插入E2E测试所需数据
 -- 更新admin用户密码为Test@123
 -- BCrypt哈希值对应明文密码: Test@123
 UPDATE sys_user 
 SET password = '$2a$12$nZ1EMUpZQljbnEdIKzH72eHlDJKUmHmHppnTTVth/SlHs5VpSAr8C'
 WHERE username = 'admin';
 -- 更新user用户密码为Test@123
 UPDATE sys_user 
 SET password = '$2a$12$nZ1EMUpZQljbnEdIKzH72eHlDJKUmHmHppnTTVth/SlHs5VpSAr8C'
 WHERE username = 'user';
 -- 插入测试角色（如果不存在）
 INSERT INTO sys_role (role_name, role_key, role_sort, status, create_by, update_by) 
 VALUES 
 ('测试管理员', 'test_admin', 2, 1, 'system', 'system'),
 ('普通用户', 'normal_user', 3, 1, 'system', 'system'),
 ('访客', 'guest', 4, 1, 'system', 'system')
 ON CONFLICT (role_key) DO NOTHING;
 -- 为admin用户分配超级管理员角色
 INSERT INTO user_role (user_id, role_id, created_by)
 SELECT 1, id, 'system' FROM sys_role WHERE role_key = 'admin'
 ON CONFLICT DO NOTHING;
 -- 为user用户分配普通用户角色
 INSERT INTO user_role (user_id, role_id, created_by)
 SELECT 2, id, 'system' FROM sys_role WHERE role_key = 'normal_user'
 ON CONFLICT DO NOTHING;
 -- 插入E2E测试专用用户
 -- BCrypt哈希值对应明文密码: Test@123
 INSERT INTO sys_user (id, username, password, email, phone, nickname, status, create_by, update_by) 
 VALUES 
 (10, 'e2e_test_user', '$2a$12$nZ1EMUpZQljbnEdIKzH72eHlDJKUmHmHppnTTVth/SlHs5VpSAr8C', 'e2e@test.com', '13900139000', 'E2E测试用户', 1, 'system', 'system')
 ON CONFLICT (username) DO UPDATE SET 
    password = EXCLUDED.password,
    status = EXCLUDED.status;
 -- 为E2E测试用户分配超级管理员角色
 INSERT INTO user_role (user_id, role_id, created_by)
 SELECT 10, id, 'system' FROM sys_role WHERE role_key = 'admin'
 ON CONFLICT DO NOTHING;
@@ -0,0 +1,28 @@
 -- V14__Fix_menu_data.sql
 -- 清理测试菜单数据
 DELETE FROM sys_menu WHERE menu_name LIKE '%测试%' OR menu_name LIKE '%回归%';
 -- 插入一级菜单
 INSERT INTO sys_menu (menu_name, parent_id, order_num, menu_type, status, created_at, updated_at) VALUES
 ('系统管理', 0, 1, 'M', 1, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP),
 ('系统监控', 0, 2, 'M', 1, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP),
 ('审计日志', 0, 3, 'M', 1, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP);
 -- 插入二级菜单（系统管理下）
 INSERT INTO sys_menu (menu_name, parent_id, order_num, menu_type, component, perms, status, created_at, updated_at) VALUES
 ('用户管理', (SELECT id FROM sys_menu WHERE menu_name = '系统管理' AND parent_id = 0), 1, 'C', 'system/user/index', 'system:user:list', 1, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP),
 ('角色管理', (SELECT id FROM sys_menu WHERE menu_name = '系统管理' AND parent_id = 0), 2, 'C', 'system/role/index', 'system:role:list', 1, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP),
 ('菜单管理', (SELECT id FROM sys_menu WHERE menu_name = '系统管理' AND parent_id = 0), 3, 'C', 'system/menu/index', 'system:menu:list', 1, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP),
 ('参数配置', (SELECT id FROM sys_menu WHERE menu_name = '系统管理' AND parent_id = 0), 4, 'C', 'system/config/index', 'system:config:list', 1, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP),
 ('字典管理', (SELECT id FROM sys_menu WHERE menu_name = '系统管理' AND parent_id = 0), 5, 'C', 'system/dict/index', 'system:dict:list', 1, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP);
 -- 插入二级菜单（系统监控下）
 INSERT INTO sys_menu (menu_name, parent_id, order_num, menu_type, component, perms, status, created_at, updated_at) VALUES
 ('文件管理', (SELECT id FROM sys_menu WHERE menu_name = '系统监控' AND parent_id = 0), 1, 'C', 'system/file/index', 'system:file:list', 1, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP),
 ('通知公告', (SELECT id FROM sys_menu WHERE menu_name = '系统监控' AND parent_id = 0), 2, 'C', 'system/notice/index', 'system:notice:list', 1, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP);
 -- 插入二级菜单（审计日志下）
 INSERT INTO sys_menu (menu_name, parent_id, order_num, menu_type, component, perms, status, created_at, updated_at) VALUES
 ('登录日志', (SELECT id FROM sys_menu WHERE menu_name = '审计日志' AND parent_id = 0), 1, 'C', 'audit/login/index', 'audit:login:list', 1, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP),
 ('操作日志', (SELECT id FROM sys_menu WHERE menu_name = '审计日志' AND parent_id = 0), 2, 'C', 'audit/operation/index', 'audit:operation:list', 1, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP),
 ('异常日志', (SELECT id FROM sys_menu WHERE menu_name = '审计日志' AND parent_id = 0), 3, 'C', 'audit/exception/index', 'audit:exception:list', 1, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP);
@@ -0,0 +1,12 @@
 -- Novalon管理系统审计日志表补充字段
 -- 版本: V15
 -- 描述: 为审计日志表添加缺失的基础字段，与BaseDomain保持一致
 ALTER TABLE audit_log ADD COLUMN IF NOT EXISTS create_by VARCHAR(50);
 ALTER TABLE audit_log ADD COLUMN IF NOT EXISTS update_by VARCHAR(50);
 ALTER TABLE audit_log ADD COLUMN IF NOT EXISTS updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP;
 ALTER TABLE audit_log ADD COLUMN IF NOT EXISTS deleted_at TIMESTAMP;
 COMMENT ON COLUMN audit_log.create_by IS '创建人';
 COMMENT ON COLUMN audit_log.update_by IS '更新人';
 COMMENT ON COLUMN audit_log.updated_at IS '更新时间';
 COMMENT ON COLUMN audit_log.deleted_at IS '删除时间';
@@ -1,31 +1,25 @@
 -- Novalon管理系统数据库初始化脚本
 -- 版本: V1
-- 描述: 创建所有核心表结构（合并版）
+-- 描述: 创建所有核心表结构
 -- ============================================
 -- 用户与角色相关表
 -- ============================================
 -- 用户表
 CREATE TABLE IF NOT EXISTS sys_user (
-    id BIGSERIAL PRIMARY KEY,
+    id BIGINT PRIMARY KEY,
    username VARCHAR(50) NOT NULL UNIQUE,
    password VARCHAR(255) NOT NULL,
    email VARCHAR(100),
    phone VARCHAR(20),
    nickname VARCHAR(100),
    status INTEGER DEFAULT 1,
    role_id BIGINT,
    status INTEGER DEFAULT 1,
    create_by VARCHAR(50),
    update_by VARCHAR(50),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
 -- 角色表
 CREATE TABLE IF NOT EXISTS sys_role (
-    id BIGSERIAL PRIMARY KEY,
+    id BIGINT PRIMARY KEY,
    role_name VARCHAR(100) NOT NULL,
    role_key VARCHAR(100) NOT NULL UNIQUE,
    role_sort INTEGER DEFAULT 0,
@@ -36,60 +30,9 @@ CREATE TABLE IF NOT EXISTS sys_role (
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
-
+-- 菜单表（统一使用sys_menu表名）
 -- 用户角色关联表（支持多对多关系）
 CREATE TABLE IF NOT EXISTS user_role (
    id BIGSERIAL PRIMARY KEY,
    user_id BIGINT NOT NULL,
    role_id BIGINT NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    created_by VARCHAR(50),
    CONSTRAINT fk_user_role_user FOREIGN KEY (user_id) REFERENCES sys_user(id) ON DELETE CASCADE,
    CONSTRAINT fk_user_role_role FOREIGN KEY (role_id) REFERENCES sys_role(id) ON DELETE CASCADE,
    CONSTRAINT uk_user_role UNIQUE (user_id, role_id)
 );
 -- ============================================
 -- 权限相关表
 -- ============================================
 -- 权限表
 CREATE TABLE IF NOT EXISTS sys_permission (
    id BIGSERIAL PRIMARY KEY,
    permission_name VARCHAR(100) NOT NULL,
    permission_code VARCHAR(100) NOT NULL UNIQUE,
    resource VARCHAR(200) NOT NULL,
    action VARCHAR(50) NOT NULL,
    description VARCHAR(500),
    status INTEGER DEFAULT 1,
    create_by VARCHAR(50),
    update_by VARCHAR(50),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
 -- 角色权限关联表
 CREATE TABLE IF NOT EXISTS sys_role_permission (
    id BIGSERIAL PRIMARY KEY,
    role_id BIGINT NOT NULL,
    permission_id BIGINT NOT NULL,
    create_by VARCHAR(50),
    update_by VARCHAR(50),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (role_id) REFERENCES sys_role(id) ON DELETE CASCADE,
    FOREIGN KEY (permission_id) REFERENCES sys_permission(id) ON DELETE CASCADE,
    UNIQUE (role_id, permission_id)
 );
 -- ============================================
 -- 菜单相关表
 -- ============================================
 -- 菜单表
 CREATE TABLE IF NOT EXISTS sys_menu (
-    id BIGSERIAL PRIMARY KEY,
+    id BIGINT PRIMARY KEY,
    menu_name VARCHAR(50) NOT NULL,
    parent_id BIGINT DEFAULT 0,
    order_num INTEGER DEFAULT 0,
@@ -103,14 +46,9 @@ CREATE TABLE IF NOT EXISTS sys_menu (
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
 -- ============================================
 -- 字典相关表
 -- ============================================
 -- 字典类型表
 CREATE TABLE IF NOT EXISTS sys_dict_type (
-    id BIGSERIAL PRIMARY KEY,
+    id BIGINT PRIMARY KEY,
    dict_name VARCHAR(100) NOT NULL,
    dict_type VARCHAR(100) NOT NULL UNIQUE,
    status VARCHAR(1) DEFAULT '0',
@@ -121,10 +59,9 @@ CREATE TABLE IF NOT EXISTS sys_dict_type (
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
 -- 字典数据表
 CREATE TABLE IF NOT EXISTS sys_dict_data (
-    id BIGSERIAL PRIMARY KEY,
+    id BIGINT PRIMARY KEY,
    dict_sort INTEGER DEFAULT 0,
    dict_label VARCHAR(100) NOT NULL,
    dict_value VARCHAR(100) NOT NULL,
@@ -139,10 +76,9 @@ CREATE TABLE IF NOT EXISTS sys_dict_data (
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
 -- 字典表（通用字典）
 CREATE TABLE IF NOT EXISTS sys_dictionary (
-    id BIGSERIAL PRIMARY KEY,
+    id BIGINT PRIMARY KEY,
    type VARCHAR(100) NOT NULL,
    code VARCHAR(100) NOT NULL,
    name VARCHAR(100) NOT NULL,
@@ -154,14 +90,9 @@ CREATE TABLE IF NOT EXISTS sys_dictionary (
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
 -- ============================================
 -- 系统配置表
 -- ============================================
 -- 系统配置表
 CREATE TABLE IF NOT EXISTS sys_config (
-    id BIGSERIAL PRIMARY KEY,
+    id BIGINT PRIMARY KEY,
    config_name VARCHAR(100) NOT NULL,
    config_key VARCHAR(100) NOT NULL UNIQUE,
    config_value VARCHAR(500) NOT NULL,
@@ -172,14 +103,9 @@ CREATE TABLE IF NOT EXISTS sys_config (
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
 -- ============================================
 -- 日志相关表
 -- ============================================
 -- 登录日志表
 CREATE TABLE IF NOT EXISTS sys_login_log (
-    id BIGSERIAL PRIMARY KEY,
+    id BIGINT PRIMARY KEY,
    username VARCHAR(50),
    ip VARCHAR(50),
    location VARCHAR(255),
@@ -189,10 +115,9 @@ CREATE TABLE IF NOT EXISTS sys_login_log (
    message VARCHAR(255),
    login_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP
 );
 -- 异常日志表
 CREATE TABLE IF NOT EXISTS sys_exception_log (
-    id BIGSERIAL PRIMARY KEY,
+    id BIGINT PRIMARY KEY,
    username VARCHAR(50),
    title VARCHAR(100),
    exception_name VARCHAR(100),
@@ -203,10 +128,9 @@ CREATE TABLE IF NOT EXISTS sys_exception_log (
    ip VARCHAR(50),
    create_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP
 );
 -- 操作日志表
 CREATE TABLE IF NOT EXISTS operation_log (
-    id BIGSERIAL PRIMARY KEY,
+    id BIGINT PRIMARY KEY,
    username VARCHAR(50),
    operation VARCHAR(100),
    method VARCHAR(200),
@@ -222,53 +146,9 @@ CREATE TABLE IF NOT EXISTS operation_log (
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
 -- 审计日志表
 CREATE TABLE IF NOT EXISTS audit_log (
    id BIGSERIAL PRIMARY KEY,
    entity_type VARCHAR(100) NOT NULL,
    entity_id BIGINT,
    operation_type VARCHAR(20) NOT NULL,
    operator VARCHAR(100),
    operation_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    before_data JSONB,
    after_data JSONB,
    changed_fields TEXT[],
    ip_address VARCHAR(50),
    user_agent TEXT,
    description TEXT,
    create_by VARCHAR(50),
    update_by VARCHAR(50),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
 -- 审计日志归档表
 CREATE TABLE IF NOT EXISTS audit_log_archive (
    id BIGSERIAL PRIMARY KEY,
    entity_type VARCHAR(100) NOT NULL,
    entity_id BIGINT,
    operation_type VARCHAR(20) NOT NULL,
    operator VARCHAR(100),
    operation_time TIMESTAMP,
    before_data JSONB,
    after_data JSONB,
    changed_fields TEXT[],
    ip_address VARCHAR(50),
    user_agent TEXT,
    description TEXT,
    created_at TIMESTAMP,
    archived_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
 );
 -- ============================================
 -- 通知与消息表
 -- ============================================
 -- 系统公告表
 CREATE TABLE IF NOT EXISTS sys_notice (
-    id BIGSERIAL PRIMARY KEY,
+    id BIGINT PRIMARY KEY,
    notice_title VARCHAR(50) NOT NULL,
    notice_type VARCHAR(1) NOT NULL,
    notice_content TEXT,
@@ -279,10 +159,9 @@ CREATE TABLE IF NOT EXISTS sys_notice (
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
 -- 用户消息表
 CREATE TABLE IF NOT EXISTS sys_user_message (
-    id BIGSERIAL PRIMARY KEY,
+    id BIGINT PRIMARY KEY,
    user_id BIGINT NOT NULL,
    notice_id BIGINT,
    message_title VARCHAR(255),
@@ -295,14 +174,9 @@ CREATE TABLE IF NOT EXISTS sys_user_message (
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
 -- ============================================
 -- 文件管理表
 -- ============================================
 -- 文件管理表
 CREATE TABLE IF NOT EXISTS sys_file (
-    id BIGSERIAL PRIMARY KEY,
+    id BIGINT PRIMARY KEY,
    file_name VARCHAR(255) NOT NULL,
    file_path VARCHAR(500) NOT NULL,
    file_size BIGINT,
@@ -315,14 +189,9 @@ CREATE TABLE IF NOT EXISTS sys_file (
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
 -- ============================================
 -- OAuth2相关表
 -- ============================================
 -- OAuth2客户端表
 CREATE TABLE IF NOT EXISTS oauth2_client (
-    id BIGSERIAL PRIMARY KEY,
+    id BIGINT PRIMARY KEY,
    client_id VARCHAR(100) NOT NULL UNIQUE,
    client_secret VARCHAR(255) NOT NULL,
    client_name VARCHAR(100),
@@ -339,31 +208,7 @@ CREATE TABLE IF NOT EXISTS oauth2_client (
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
 -- ============================================
 -- 表注释
 -- ============================================
 COMMENT ON TABLE sys_user IS '系统用户表';
 COMMENT ON TABLE sys_role IS '系统角色表';
 COMMENT ON TABLE user_role IS '用户角色关联表';
 COMMENT ON TABLE sys_permission IS '系统权限表';
 COMMENT ON TABLE sys_role_permission IS '角色权限关联表';
 COMMENT ON TABLE sys_menu IS '系统菜单表';
 COMMENT ON TABLE sys_dict_type IS '字典类型表';
 COMMENT ON TABLE sys_dict_data IS '字典数据表';
 COMMENT ON TABLE sys_dictionary IS '通用字典表';
 COMMENT ON TABLE sys_config IS '系统配置表';
 COMMENT ON TABLE sys_login_log IS '登录日志表';
 COMMENT ON TABLE sys_exception_log IS '异常日志表';
 COMMENT ON TABLE operation_log IS '操作日志表';
 COMMENT ON TABLE audit_log IS '审计日志表';
 COMMENT ON TABLE audit_log_archive IS '审计日志归档表';
 COMMENT ON TABLE sys_notice IS '系统公告表';
 COMMENT ON TABLE sys_user_message IS '用户消息表';
 COMMENT ON TABLE sys_file IS '文件管理表';
 COMMENT ON TABLE oauth2_client IS 'OAuth2客户端表';
 COMMENT ON TABLE sys_exception_log IS '异常日志表';
 COMMENT ON COLUMN sys_exception_log.id IS '主键ID';
 COMMENT ON COLUMN sys_exception_log.username IS '操作用户';
@@ -375,33 +220,5 @@ COMMENT ON COLUMN sys_exception_log.exception_msg IS '异常消息';
 COMMENT ON COLUMN sys_exception_log.exception_stack IS '异常堆栈';
 COMMENT ON COLUMN sys_exception_log.ip IS 'IP地址';
 COMMENT ON COLUMN sys_exception_log.create_time IS '创建时间';
-
+COMMENT ON TABLE sys_menu IS '系统菜单表';
-COMMENT ON TABLE audit_log IS '审计日志表';
+COMMENT ON TABLE sys_login_log IS '登录日志表';
 COMMENT ON COLUMN audit_log.id IS '主键ID';
 COMMENT ON COLUMN audit_log.entity_type IS '实体类型（如User, Role等）';
 COMMENT ON COLUMN audit_log.entity_id IS '实体ID';
 COMMENT ON COLUMN audit_log.operation_type IS '操作类型（CREATE, UPDATE, DELETE）';
 COMMENT ON COLUMN audit_log.operator IS '操作人';
 COMMENT ON COLUMN audit_log.operation_time IS '操作时间';
 COMMENT ON COLUMN audit_log.before_data IS '变更前数据（JSON格式）';
 COMMENT ON COLUMN audit_log.after_data IS '变更后数据（JSON格式）';
 COMMENT ON COLUMN audit_log.changed_fields IS '变更字段列表';
 COMMENT ON COLUMN audit_log.ip_address IS 'IP地址';
 COMMENT ON COLUMN audit_log.description IS '操作描述';
 COMMENT ON COLUMN audit_log.created_at IS '记录创建时间';
 COMMENT ON TABLE audit_log_archive IS '审计日志归档表';
 COMMENT ON COLUMN audit_log_archive.id IS '主键ID';
 COMMENT ON COLUMN audit_log_archive.entity_type IS '实体类型（如User, Role等）';
 COMMENT ON COLUMN audit_log_archive.entity_id IS '实体ID';
 COMMENT ON COLUMN audit_log_archive.operation_type IS '操作类型（CREATE, UPDATE, DELETE）';
 COMMENT ON COLUMN audit_log_archive.operator IS '操作人';
 COMMENT ON COLUMN audit_log_archive.operation_time IS '操作时间';
 COMMENT ON COLUMN audit_log_archive.before_data IS '变更前数据（JSON格式）';
 COMMENT ON COLUMN audit_log_archive.after_data IS '变更后数据（JSON格式）';
 COMMENT ON COLUMN audit_log_archive.changed_fields IS '变更字段列表';
 COMMENT ON COLUMN audit_log_archive.ip_address IS 'IP地址';
 COMMENT ON COLUMN audit_log_archive.user_agent IS '用户代理';
 COMMENT ON COLUMN audit_log_archive.description IS '操作描述';
 COMMENT ON COLUMN audit_log_archive.created_at IS '记录创建时间';
 COMMENT ON COLUMN audit_log_archive.archived_at IS '归档时间';
@@ -1,233 +1,67 @@
 -- Novalon管理系统初始数据脚本
 -- 版本: V2
-- 描述: 插入所有必要的初始数据（合并版）
+-- 描述: 插入必要的初始数据
-- ============================================
+-- 插入初始角色
-- 角色数据
+INSERT INTO sys_role (role_name, role_key, role_sort, status, create_by, update_by) 
-- ============================================
+VALUES ('超级管理员', 'admin', 1, 1, 'system', 'system')
 ON CONFLICT (role_key) DO NOTHING;
-INSERT INTO sys_role (id, role_name, role_key, role_sort, status, create_by, update_by, created_at, updated_at) 
+-- 插入初始管理员用户
-VALUES 
+-- BCrypt哈希值对应明文密码: admin123
-(1, '超级管理员', 'admin', 1, 1, 'system', 'system', NOW(), NOW()),
+INSERT INTO sys_user (id, username, password, email, phone, status, create_by, update_by) 
-(2, '测试管理员', 'test_admin', 2, 1, 'system', 'system', NOW(), NOW()),
+VALUES (1, 'admin', '$2b$12$SFefXlGRFMA0fvxIufpWPuIAl0OPLgRDoCZPThCvjpiJGPYS8yNYy', 'admin@novalon.com', '13800138000', 1, 'system', 'system')
 (3, '普通用户', 'normal_user', 3, 1, 'system', 'system', NOW(), NOW()),
 (4, '访客', 'guest', 4, 1, 'system', 'system', NOW(), NOW());
 SELECT setval('sys_role_id_seq', 4);
 -- ============================================
 -- 用户数据
 -- ============================================
 -- 密码均为: Test@123 (BCrypt哈希)
 INSERT INTO sys_user (id, username, password, email, phone, nickname, status, create_by, update_by, created_at, updated_at) 
 VALUES 
 (1, 'admin', '$2a$12$nZ1EMUpZQljbnEdIKzH72eHlDJKUmHmHppnTTVth/SlHs5VpSAr8C', 'admin@novalon.com', '13800138000', '超级管理员', 1, 'system', 'system', NOW(), NOW()),
 (2, 'user', '$2a$12$nZ1EMUpZQljbnEdIKzH72eHlDJKUmHmHppnTTVth/SlHs5VpSAr8C', 'user@novalon.com', '13800138001', '普通用户', 1, 'system', 'system', NOW(), NOW()),
 (10, 'e2e_test_user', '$2a$12$nZ1EMUpZQljbnEdIKzH72eHlDJKUmHmHppnTTVth/SlHs5VpSAr8C', 'e2e@test.com', '13900139000', 'E2E测试用户', 1, 'system', 'system', NOW(), NOW())
 ON CONFLICT (username) DO UPDATE SET 
    password = EXCLUDED.password,
    status = EXCLUDED.status;
-SELECT setval('sys_user_id_seq', 10);
+-- 插入测试用户（用于E2E测试）
 -- BCrypt哈希值对应明文密码: admin123
 INSERT INTO sys_user (id, username, password, email, phone, status, create_by, update_by) 
 VALUES (2, 'user', '$2b$12$SFefXlGRFMA0fvxIufpWPuIAl0OPLgRDoCZPThCvjpiJGPYS8yNYy', 'user@novalon.com', '13800138001', 1, 'system', 'system')
 ON CONFLICT (username) DO UPDATE SET 
    password = EXCLUDED.password,
    status = EXCLUDED.status;
-- ============================================
+-- 插入初始字典类型
-- 用户角色关联
+INSERT INTO sys_dict_type (dict_name, dict_type, status, remark, create_by, update_by) 
 -- ============================================
 -- 为admin用户分配超级管理员角色
 INSERT INTO user_role (user_id, role_id, created_by, created_at) 
 VALUES 
-(1, 1, 'system', NOW()),
+('用户状态', 'user_status', '0', '用户状态列表', 'system', 'system'),
-(2, 3, 'system', NOW()),
+('菜单状态', 'menu_status', '0', '菜单状态列表', 'system', 'system'),
-(10, 1, 'system', NOW())
+('角色状态', 'role_status', '0', '角色状态列表', 'system', 'system'),
-ON CONFLICT (user_id, role_id) DO NOTHING;
+('系统开关', 'sys_normal_disable', '0', '系统开关列表', 'system', 'system')
 -- ============================================
 -- 权限数据
 -- ============================================
 INSERT INTO sys_permission (permission_name, permission_code, resource, action, description, status, create_by, update_by, created_at, updated_at) VALUES
 ('用户查看', 'system:user:view', '/api/users', 'GET', '查看用户列表', 1, 'system', 'system', NOW(), NOW()),
 ('用户创建', 'system:user:create', '/api/users', 'POST', '创建用户', 1, 'system', 'system', NOW(), NOW()),
 ('用户编辑', 'system:user:edit', '/api/users', 'PUT', '编辑用户', 1, 'system', 'system', NOW(), NOW()),
 ('用户删除', 'system:user:delete', '/api/users', 'DELETE', '删除用户', 1, 'system', 'system', NOW(), NOW()),
 ('角色查看', 'system:role:view', '/api/roles', 'GET', '查看角色列表', 1, 'system', 'system', NOW(), NOW()),
 ('角色创建', 'system:role:create', '/api/roles', 'POST', '创建角色', 1, 'system', 'system', NOW(), NOW()),
 ('角色编辑', 'system:role:edit', '/api/roles', 'PUT', '编辑角色', 1, 'system', 'system', NOW(), NOW()),
 ('角色删除', 'system:role:delete', '/api/roles', 'DELETE', '删除角色', 1, 'system', 'system', NOW(), NOW()),
 ('角色分配权限', 'system:role:assign', '/api/roles/*/permissions', 'POST', '为角色分配权限', 1, 'system', 'system', NOW(), NOW()),
 ('权限查看', 'system:permission:view', '/api/permissions', 'GET', '查看权限列表', 1, 'system', 'system', NOW(), NOW()),
 ('权限创建', 'system:permission:create', '/api/permissions', 'POST', '创建权限', 1, 'system', 'system', NOW(), NOW()),
 ('权限编辑', 'system:permission:edit', '/api/permissions', 'PUT', '编辑权限', 1, 'system', 'system', NOW(), NOW()),
 ('权限删除', 'system:permission:delete', '/api/permissions', 'DELETE', '删除权限', 1, 'system', 'system', NOW(), NOW()),
 ('菜单查看', 'system:menu:view', '/api/menus', 'GET', '查看菜单列表', 1, 'system', 'system', NOW(), NOW()),
 ('菜单创建', 'system:menu:create', '/api/menus', 'POST', '创建菜单', 1, 'system', 'system', NOW(), NOW()),
 ('菜单编辑', 'system:menu:edit', '/api/menus', 'PUT', '编辑菜单', 1, 'system', 'system', NOW(), NOW()),
 ('菜单删除', 'system:menu:delete', '/api/menus', 'DELETE', '删除菜单', 1, 'system', 'system', NOW(), NOW()),
 ('字典查看', 'system:dict:view', '/api/dict', 'GET', '查看字典列表', 1, 'system', 'system', NOW(), NOW()),
 ('字典创建', 'system:dict:create', '/api/dict', 'POST', '创建字典', 1, 'system', 'system', NOW(), NOW()),
 ('字典编辑', 'system:dict:edit', '/api/dict', 'PUT', '编辑字典', 1, 'system', 'system', NOW(), NOW()),
 ('字典删除', 'system:dict:delete', '/api/dict', 'DELETE', '删除字典', 1, 'system', 'system', NOW(), NOW()),
 ('配置查看', 'system:config:view', '/api/config', 'GET', '查看系统配置', 1, 'system', 'system', NOW(), NOW()),
 ('配置创建', 'system:config:create', '/api/config', 'POST', '创建系统配置', 1, 'system', 'system', NOW(), NOW()),
 ('配置编辑', 'system:config:edit', '/api/config', 'PUT', '编辑系统配置', 1, 'system', 'system', NOW(), NOW()),
 ('配置删除', 'system:config:delete', '/api/config', 'DELETE', '删除系统配置', 1, 'system', 'system', NOW(), NOW()),
 ('日志查看', 'system:log:view', '/api/logs', 'GET', '查看日志', 1, 'system', 'system', NOW(), NOW()),
 ('文件上传', 'system:file:upload', '/api/files/upload', 'POST', '上传文件', 1, 'system', 'system', NOW(), NOW()),
 ('文件下载', 'system:file:download', '/api/files/download', 'GET', '下载文件', 1, 'system', 'system', NOW(), NOW()),
 ('文件删除', 'system:file:delete', '/api/files', 'DELETE', '删除文件', 1, 'system', 'system', NOW(), NOW()),
 ('公告查看', 'system:notice:view', '/api/notices', 'GET', '查看公告', 1, 'system', 'system', NOW(), NOW()),
 ('公告创建', 'system:notice:create', '/api/notices', 'POST', '创建公告', 1, 'system', 'system', NOW(), NOW()),
 ('公告编辑', 'system:notice:edit', '/api/notices', 'PUT', '编辑公告', 1, 'system', 'system', NOW(), NOW()),
 ('公告删除', 'system:notice:delete', '/api/notices', 'DELETE', '删除公告', 1, 'system', 'system', NOW(), NOW());
 -- 为管理员角色分配所有权限
 INSERT INTO sys_role_permission (role_id, permission_id, create_by, update_by, created_at, updated_at)
 SELECT 1, id, 'system', 'system', NOW(), NOW() FROM sys_permission WHERE status = 1;
 -- ============================================
 -- 菜单数据
 -- ============================================
 -- 一级菜单
 INSERT INTO sys_menu (id, menu_name, parent_id, order_num, menu_type, perms, component, status, created_at, updated_at) VALUES
 (1, '系统管理', 0, 1, 'M', NULL, NULL, 1, NOW(), NOW()),
 (2, '审计日志', 0, 2, 'M', NULL, NULL, 1, NOW(), NOW()),
 (3, '系统监控', 0, 3, 'M', NULL, NULL, 1, NOW(), NOW());
 -- 系统管理子菜单
 INSERT INTO sys_menu (id, menu_name, parent_id, order_num, menu_type, perms, component, status, created_at, updated_at) VALUES
 (11, '用户管理', 1, 1, 'C', 'system:user:list', 'system/user/index', 1, NOW(), NOW()),
 (12, '角色管理', 1, 2, 'C', 'system:role:list', 'system/role/index', 1, NOW(), NOW()),
 (13, '菜单管理', 1, 3, 'C', 'system:menu:list', 'system/menu/index', 1, NOW(), NOW()),
 (14, '部门管理', 1, 4, 'C', 'system:dept:list', 'system/dept/index', 1, NOW(), NOW()),
 (15, '字典管理', 1, 5, 'C', 'system:dict:list', 'system/dict/index', 1, NOW(), NOW()),
 (16, '参数管理', 1, 6, 'C', 'system:config:list', 'system/config/index', 1, NOW(), NOW()),
 (17, '通知公告', 1, 7, 'C', 'system:notice:list', 'system/notice/index', 1, NOW(), NOW()),
 (18, '文件管理', 1, 8, 'C', 'system:file:list', 'system/file/index', 1, NOW(), NOW());
 -- 用户管理按钮权限
 INSERT INTO sys_menu (id, menu_name, parent_id, order_num, menu_type, perms, component, status, created_at, updated_at) VALUES
 (111, '用户查询', 11, 1, 'F', 'system:user:query', NULL, 1, NOW(), NOW()),
 (112, '用户新增', 11, 2, 'F', 'system:user:add', NULL, 1, NOW(), NOW()),
 (113, '用户修改', 11, 3, 'F', 'system:user:edit', NULL, 1, NOW(), NOW()),
 (114, '用户删除', 11, 4, 'F', 'system:user:remove', NULL, 1, NOW(), NOW()),
 (115, '用户导出', 11, 5, 'F', 'system:user:export', NULL, 1, NOW(), NOW()),
 (116, '用户导入', 11, 6, 'F', 'system:user:import', NULL, 1, NOW(), NOW()),
 (117, '重置密码', 11, 7, 'F', 'system:user:resetPwd', NULL, 1, NOW(), NOW());
 -- 角色管理按钮权限
 INSERT INTO sys_menu (id, menu_name, parent_id, order_num, menu_type, perms, component, status, created_at, updated_at) VALUES
 (121, '角色查询', 12, 1, 'F', 'system:role:query', NULL, 1, NOW(), NOW()),
 (122, '角色新增', 12, 2, 'F', 'system:role:add', NULL, 1, NOW(), NOW()),
 (123, '角色修改', 12, 3, 'F', 'system:role:edit', NULL, 1, NOW(), NOW()),
 (124, '角色删除', 12, 4, 'F', 'system:role:remove', NULL, 1, NOW(), NOW()),
 (125, '角色导出', 12, 5, 'F', 'system:role:export', NULL, 1, NOW(), NOW());
 -- 菜单管理按钮权限
 INSERT INTO sys_menu (id, menu_name, parent_id, order_num, menu_type, perms, component, status, created_at, updated_at) VALUES
 (131, '菜单查询', 13, 1, 'F', 'system:menu:query', NULL, 1, NOW(), NOW()),
 (132, '菜单新增', 13, 2, 'F', 'system:menu:add', NULL, 1, NOW(), NOW()),
 (133, '菜单修改', 13, 3, 'F', 'system:menu:edit', NULL, 1, NOW(), NOW()),
 (134, '菜单删除', 13, 4, 'F', 'system:menu:remove', NULL, 1, NOW(), NOW());
 -- 审计日志子菜单
 INSERT INTO sys_menu (id, menu_name, parent_id, order_num, menu_type, perms, component, status, created_at, updated_at) VALUES
 (21, '操作日志', 2, 1, 'C', 'audit:operation:list', 'audit/operation/index', 1, NOW(), NOW()),
 (22, '登录日志', 2, 2, 'C', 'audit:login:list', 'audit/login/index', 1, NOW(), NOW()),
 (23, '异常日志', 2, 3, 'C', 'audit:exception:list', 'audit/exception/index', 1, NOW(), NOW());
 -- 操作日志按钮权限
 INSERT INTO sys_menu (id, menu_name, parent_id, order_num, menu_type, perms, component, status, created_at, updated_at) VALUES
 (211, '操作查询', 21, 1, 'F', 'audit:operation:query', NULL, 1, NOW(), NOW()),
 (212, '操作删除', 21, 2, 'F', 'audit:operation:remove', NULL, 1, NOW(), NOW()),
 (213, '操作导出', 21, 3, 'F', 'audit:operation:export', NULL, 1, NOW(), NOW());
 -- 登录日志按钮权限
 INSERT INTO sys_menu (id, menu_name, parent_id, order_num, menu_type, perms, component, status, created_at, updated_at) VALUES
 (221, '登录查询', 22, 1, 'F', 'audit:login:query', NULL, 1, NOW(), NOW()),
 (222, '登录删除', 22, 2, 'F', 'audit:login:remove', NULL, 1, NOW(), NOW()),
 (223, '登录导出', 22, 3, 'F', 'audit:login:export', NULL, 1, NOW(), NOW());
 -- 异常日志按钮权限
 INSERT INTO sys_menu (id, menu_name, parent_id, order_num, menu_type, perms, component, status, created_at, updated_at) VALUES
 (231, '异常查询', 23, 1, 'F', 'audit:exception:query', NULL, 1, NOW(), NOW()),
 (232, '异常删除', 23, 2, 'F', 'audit:exception:remove', NULL, 1, NOW(), NOW()),
 (233, '异常导出', 23, 3, 'F', 'audit:exception:export', NULL, 1, NOW(), NOW());
 -- 系统监控子菜单
 INSERT INTO sys_menu (id, menu_name, parent_id, order_num, menu_type, perms, component, status, created_at, updated_at) VALUES
 (31, '在线用户', 3, 1, 'C', 'monitor:online:list', 'monitor/online/index', 1, NOW(), NOW()),
 (32, '定时任务', 3, 2, 'C', 'monitor:job:list', 'monitor/job/index', 1, NOW(), NOW()),
 (33, '数据监控', 3, 3, 'C', 'monitor:data:list', 'monitor/data/index', 1, NOW(), NOW()),
 (34, '服务监控', 3, 4, 'C', 'monitor:server:list', 'monitor/server/index', 1, NOW(), NOW()),
 (35, '缓存监控', 3, 5, 'C', 'monitor:cache:list', 'monitor/cache/index', 1, NOW(), NOW());
 -- 在线用户按钮权限
 INSERT INTO sys_menu (id, menu_name, parent_id, order_num, menu_type, perms, component, status, created_at, updated_at) VALUES
 (311, '在线查询', 31, 1, 'F', 'monitor:online:query', NULL, 1, NOW(), NOW()),
 (312, '在线强退', 31, 2, 'F', 'monitor:online:forceLogout', NULL, 1, NOW(), NOW());
 -- 定时任务按钮权限
 INSERT INTO sys_menu (id, menu_name, parent_id, order_num, menu_type, perms, component, status, created_at, updated_at) VALUES
 (321, '任务查询', 32, 1, 'F', 'monitor:job:query', NULL, 1, NOW(), NOW()),
 (322, '任务新增', 32, 2, 'F', 'monitor:job:add', NULL, 1, NOW(), NOW()),
 (323, '任务修改', 32, 3, 'F', 'monitor:job:edit', NULL, 1, NOW(), NOW()),
 (324, '任务删除', 32, 4, 'F', 'monitor:job:remove', NULL, 1, NOW(), NOW()),
 (325, '任务执行', 32, 5, 'F', 'monitor:job:execute', NULL, 1, NOW(), NOW());
 SELECT setval('sys_menu_id_seq', 400);
 -- ============================================
 -- 字典数据
 -- ============================================
 -- 字典类型
 INSERT INTO sys_dict_type (dict_name, dict_type, status, remark, create_by, update_by, created_at, updated_at) 
 VALUES 
 ('用户状态', 'user_status', '0', '用户状态列表', 'system', 'system', NOW(), NOW()),
 ('菜单状态', 'menu_status', '0', '菜单状态列表', 'system', 'system', NOW(), NOW()),
 ('角色状态', 'role_status', '0', '角色状态列表', 'system', 'system', NOW(), NOW()),
 ('系统开关', 'sys_normal_disable', '0', '系统开关列表', 'system', 'system', NOW(), NOW())
 ON CONFLICT (dict_type) DO NOTHING;
-- 字典数据
+-- 插入初始字典数据
-INSERT INTO sys_dict_data (dict_sort, dict_label, dict_value, dict_type, css_class, list_class, is_default, status, create_by, update_by, created_at, updated_at) 
+INSERT INTO sys_dict_data (dict_sort, dict_label, dict_value, dict_type, css_class, list_class, is_default, status, create_by, update_by) 
 VALUES 
 -- 用户状态
-(1, '正常', '1', 'user_status', '', 'primary', 'Y', '0', 'system', 'system', NOW(), NOW()),
+(1, '正常', '1', 'user_status', '', 'primary', 'Y', '0', 'system', 'system'),
-(2, '停用', '0', 'user_status', '', 'danger', 'N', '0', 'system', 'system', NOW(), NOW()),
+(2, '停用', '0', 'user_status', '', 'danger', 'N', '0', 'system', 'system'),
 -- 菜单状态
-(1, '正常', '0', 'menu_status', '', 'primary', 'Y', '0', 'system', 'system', NOW(), NOW()),
+(1, '正常', '0', 'menu_status', '', 'primary', 'Y', '0', 'system', 'system'),
-(2, '停用', '1', 'menu_status', '', 'danger', 'N', '0', 'system', 'system', NOW(), NOW()),
+(2, '停用', '1', 'menu_status', '', 'danger', 'N', '0', 'system', 'system'),
 -- 角色状态
-(1, '正常', '0', 'role_status', '', 'primary', 'Y', '0', 'system', 'system', NOW(), NOW()),
+(1, '正常', '0', 'role_status', '', 'primary', 'Y', '0', 'system', 'system'),
-(2, '停用', '1', 'role_status', '', 'danger', 'N', '0', 'system', 'system', NOW(), NOW()),
+(2, '停用', '1', 'role_status', '', 'danger', 'N', '0', 'system', 'system'),
 -- 系统开关
-(1, '正常', '0', 'sys_normal_disable', '', 'primary', 'Y', '0', 'system', 'system', NOW(), NOW()),
+(1, '正常', '0', 'sys_normal_disable', '', 'primary', 'Y', '0', 'system', 'system'),
-(2, '停用', '1', 'sys_normal_disable', '', 'danger', 'N', '0', 'system', 'system', NOW(), NOW());
+(2, '停用', '1', 'sys_normal_disable', '', 'danger', 'N', '0', 'system', 'system')
 ON CONFLICT DO NOTHING;
-- ============================================
+-- 插入初始系统配置
-- 系统配置
+INSERT INTO sys_config (config_name, config_key, config_value, config_type, create_by, update_by) 
 -- ============================================
 INSERT INTO sys_config (config_name, config_key, config_value, config_type, create_by, update_by, created_at, updated_at) 
 VALUES 
-('用户管理-用户初始密码', 'sys.user.initPassword', '123456', 'Y', 'system', 'system', NOW(), NOW()),
+('用户管理-用户初始密码', 'sys.user.initPassword', '123456', 'Y', 'system', 'system'),
-('主框架页-默认皮肤样式名称', 'sys.index.skinName', 'skin-blue', 'Y', 'system', 'system', NOW(), NOW()),
+('主框架页-默认皮肤样式名称', 'sys.index.skinName', 'skin-blue', 'Y', 'system', 'system'),
-('用户自助-验证码开关', 'sys.account.captchaEnabled', 'true', 'Y', 'system', 'system', NOW(), NOW()),
+('用户自助-验证码开关', 'sys.account.captchaEnabled', 'true', 'Y', 'system', 'system'),
-('用户自助-是否开启用户注册功能', 'sys.account.registerUser', 'false', 'Y', 'system', 'system', NOW(), NOW()),
+('用户自助-是否开启用户注册功能', 'sys.account.registerUser', 'false', 'Y', 'system', 'system'),
-('账号自助-密码验证码', 'sys.account.pwdCaptchaEnabled', 'true', 'Y', 'system', 'system', NOW(), NOW())
+('账号自助-密码验证码', 'sys.account.pwdCaptchaEnabled', 'true', 'Y', 'system', 'system')
 ON CONFLICT (config_key) DO NOTHING;
 -- ============================================
 -- 重置序列值
-- ============================================
+SELECT setval('sys_user_id_seq', (SELECT COALESCE(MAX(id), 1) FROM sys_user));
-
+SELECT setval('sys_role_id_seq', (SELECT COALESCE(MAX(id), 1) FROM sys_role));
 SELECT setval('sys_dict_type_id_seq', (SELECT COALESCE(MAX(id), 1) FROM sys_dict_type));
 SELECT setval('sys_dict_data_id_seq', (SELECT COALESCE(MAX(id), 1) FROM sys_dict_data));
 SELECT setval('sys_config_id_seq', (SELECT COALESCE(MAX(id), 1) FROM sys_config));
 SELECT setval('sys_permission_id_seq', (SELECT COALESCE(MAX(id), 1) FROM sys_permission));
 SELECT setval('sys_role_permission_id_seq', (SELECT COALESCE(MAX(id), 1) FROM sys_role_permission));
 SELECT setval('user_role_id_seq', (SELECT COALESCE(MAX(id), 1) FROM user_role));
@@ -0,0 +1,23 @@
 -- 创建用户角色关联表（支持多对多关系）
 CREATE TABLE IF NOT EXISTS user_role (
    id BIGSERIAL PRIMARY KEY,
    user_id BIGINT NOT NULL,
    role_id BIGINT NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    created_by VARCHAR(50),
    CONSTRAINT fk_user_role_user FOREIGN KEY (user_id) REFERENCES sys_user(id) ON DELETE CASCADE,
    CONSTRAINT fk_user_role_role FOREIGN KEY (role_id) REFERENCES sys_role(id) ON DELETE CASCADE,
    CONSTRAINT uk_user_role UNIQUE (user_id, role_id)
 );
 -- 创建索引
 CREATE INDEX IF NOT EXISTS idx_user_role_user_id ON user_role(user_id);
 CREATE INDEX IF NOT EXISTS idx_user_role_role_id ON user_role(role_id);
 -- 表注释
 COMMENT ON TABLE user_role IS '用户角色关联表';
 COMMENT ON COLUMN user_role.id IS '主键ID';
 COMMENT ON COLUMN user_role.user_id IS '用户ID';
 COMMENT ON COLUMN user_role.role_id IS '角色ID';
 COMMENT ON COLUMN user_role.created_at IS '创建时间';
 COMMENT ON COLUMN user_role.created_by IS '创建人';
@@ -0,0 +1,104 @@
 -- Novalon管理系统权限功能数据库迁移脚本
 -- 版本: V4
 -- 描述: 创建权限管理相关表结构
 -- 权限表
 CREATE TABLE IF NOT EXISTS sys_permission (
    id BIGSERIAL PRIMARY KEY,
    permission_name VARCHAR(100) NOT NULL,
    permission_code VARCHAR(100) NOT NULL UNIQUE,
    resource VARCHAR(200) NOT NULL,
    action VARCHAR(50) NOT NULL,
    description VARCHAR(500),
    status INTEGER DEFAULT 1,
    create_by VARCHAR(50),
    update_by VARCHAR(50),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
 -- 角色权限关联表
 CREATE TABLE IF NOT EXISTS sys_role_permission (
    id BIGSERIAL PRIMARY KEY,
    role_id BIGINT NOT NULL,
    permission_id BIGINT NOT NULL,
    create_by VARCHAR(50),
    update_by VARCHAR(50),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (role_id) REFERENCES sys_role(id) ON DELETE CASCADE,
    FOREIGN KEY (permission_id) REFERENCES sys_permission(id) ON DELETE CASCADE,
    UNIQUE (role_id, permission_id)
 );
 -- 表注释
 COMMENT ON TABLE sys_permission IS '系统权限表';
 COMMENT ON COLUMN sys_permission.id IS '主键ID';
 COMMENT ON COLUMN sys_permission.permission_name IS '权限名称';
 COMMENT ON COLUMN sys_permission.permission_code IS '权限编码';
 COMMENT ON COLUMN sys_permission.resource IS '资源路径';
 COMMENT ON COLUMN sys_permission.action IS '操作类型';
 COMMENT ON COLUMN sys_permission.description IS '权限描述';
 COMMENT ON COLUMN sys_permission.status IS '状态：0-禁用，1-正常';
 COMMENT ON COLUMN sys_permission.create_by IS '创建者';
 COMMENT ON COLUMN sys_permission.update_by IS '更新者';
 COMMENT ON COLUMN sys_permission.created_at IS '创建时间';
 COMMENT ON COLUMN sys_permission.updated_at IS '更新时间';
 COMMENT ON COLUMN sys_permission.deleted_at IS '删除时间';
 COMMENT ON TABLE sys_role_permission IS '角色权限关联表';
 COMMENT ON COLUMN sys_role_permission.id IS '主键ID';
 COMMENT ON COLUMN sys_role_permission.role_id IS '角色ID';
 COMMENT ON COLUMN sys_role_permission.permission_id IS '权限ID';
 COMMENT ON COLUMN sys_role_permission.create_by IS '创建者';
 COMMENT ON COLUMN sys_role_permission.update_by IS '更新者';
 COMMENT ON COLUMN sys_role_permission.created_at IS '创建时间';
 COMMENT ON COLUMN sys_role_permission.updated_at IS '更新时间';
 -- 创建索引
 CREATE INDEX IF NOT EXISTS idx_permission_code ON sys_permission(permission_code);
 CREATE INDEX IF NOT EXISTS idx_permission_resource ON sys_permission(resource);
 CREATE INDEX IF NOT EXISTS idx_permission_status ON sys_permission(status);
 CREATE INDEX IF NOT EXISTS idx_role_permission_role_id ON sys_role_permission(role_id);
 CREATE INDEX IF NOT EXISTS idx_role_permission_permission_id ON sys_role_permission(permission_id);
 -- 插入初始权限数据
 INSERT INTO sys_permission (permission_name, permission_code, resource, action, description, status) VALUES
 ('用户查看', 'system:user:view', '/api/users', 'GET', '查看用户列表', 1),
 ('用户创建', 'system:user:create', '/api/users', 'POST', '创建用户', 1),
 ('用户编辑', 'system:user:edit', '/api/users', 'PUT', '编辑用户', 1),
 ('用户删除', 'system:user:delete', '/api/users', 'DELETE', '删除用户', 1),
 ('角色查看', 'system:role:view', '/api/roles', 'GET', '查看角色列表', 1),
 ('角色创建', 'system:role:create', '/api/roles', 'POST', '创建角色', 1),
 ('角色编辑', 'system:role:edit', '/api/roles', 'PUT', '编辑角色', 1),
 ('角色删除', 'system:role:delete', '/api/roles', 'DELETE', '删除角色', 1),
 ('角色分配权限', 'system:role:assign', '/api/roles/*/permissions', 'POST', '为角色分配权限', 1),
 ('权限查看', 'system:permission:view', '/api/permissions', 'GET', '查看权限列表', 1),
 ('权限创建', 'system:permission:create', '/api/permissions', 'POST', '创建权限', 1),
 ('权限编辑', 'system:permission:edit', '/api/permissions', 'PUT', '编辑权限', 1),
 ('权限删除', 'system:permission:delete', '/api/permissions', 'DELETE', '删除权限', 1),
 ('菜单查看', 'system:menu:view', '/api/menus', 'GET', '查看菜单列表', 1),
 ('菜单创建', 'system:menu:create', '/api/menus', 'POST', '创建菜单', 1),
 ('菜单编辑', 'system:menu:edit', '/api/menus', 'PUT', '编辑菜单', 1),
 ('菜单删除', 'system:menu:delete', '/api/menus', 'DELETE', '删除菜单', 1),
 ('字典查看', 'system:dict:view', '/api/dict', 'GET', '查看字典列表', 1),
 ('字典创建', 'system:dict:create', '/api/dict', 'POST', '创建字典', 1),
 ('字典编辑', 'system:dict:edit', '/api/dict', 'PUT', '编辑字典', 1),
 ('字典删除', 'system:dict:delete', '/api/dict', 'DELETE', '删除字典', 1),
 ('配置查看', 'system:config:view', '/api/config', 'GET', '查看系统配置', 1),
 ('配置创建', 'system:config:create', '/api/config', 'POST', '创建系统配置', 1),
 ('配置编辑', 'system:config:edit', '/api/config', 'PUT', '编辑系统配置', 1),
 ('配置删除', 'system:config:delete', '/api/config', 'DELETE', '删除系统配置', 1),
 ('日志查看', 'system:log:view', '/api/logs', 'GET', '查看日志', 1),
 ('文件上传', 'system:file:upload', '/api/files/upload', 'POST', '上传文件', 1),
 ('文件下载', 'system:file:download', '/api/files/download', 'GET', '下载文件', 1),
 ('文件删除', 'system:file:delete', '/api/files', 'DELETE', '删除文件', 1),
 ('公告查看', 'system:notice:view', '/api/notices', 'GET', '查看公告', 1),
 ('公告创建', 'system:notice:create', '/api/notices', 'POST', '创建公告', 1),
 ('公告编辑', 'system:notice:edit', '/api/notices', 'PUT', '编辑公告', 1),
 ('公告删除', 'system:notice:delete', '/api/notices', 'DELETE', '删除公告', 1);
 -- 为管理员角色分配所有权限
 INSERT INTO sys_role_permission (role_id, permission_id)
 SELECT 1, id FROM sys_permission WHERE status = 1;
@@ -1,11 +1,7 @@
 -- Novalon管理系统索引优化脚本
-- 版本: V3
+-- 版本: V5
 -- 描述: 为表创建必要的索引以提升查询性能
 -- ============================================
 -- 用户与角色表索引
 -- ============================================
 -- 用户表索引
 CREATE INDEX IF NOT EXISTS idx_users_username ON sys_user(username);
 CREATE INDEX IF NOT EXISTS idx_users_email ON sys_user(email);
@@ -17,35 +13,11 @@ CREATE INDEX IF NOT EXISTS idx_roles_role_key ON sys_role(role_key);
 CREATE INDEX IF NOT EXISTS idx_roles_status ON sys_role(status);
 CREATE INDEX IF NOT EXISTS idx_roles_deleted_at ON sys_role(deleted_at);
 -- 用户角色关联表索引
 CREATE INDEX IF NOT EXISTS idx_user_role_user_id ON user_role(user_id);
 CREATE INDEX IF NOT EXISTS idx_user_role_role_id ON user_role(role_id);
 -- ============================================
 -- 权限表索引
 -- ============================================
 -- 权限表索引
 CREATE INDEX IF NOT EXISTS idx_permission_code ON sys_permission(permission_code);
 CREATE INDEX IF NOT EXISTS idx_permission_resource ON sys_permission(resource);
 CREATE INDEX IF NOT EXISTS idx_permission_status ON sys_permission(status);
 -- 角色权限关联表索引
 CREATE INDEX IF NOT EXISTS idx_role_permission_role_id ON sys_role_permission(role_id);
 CREATE INDEX IF NOT EXISTS idx_role_permission_permission_id ON sys_role_permission(permission_id);
 -- ============================================
 -- 菜单表索引
 -- ============================================
 CREATE INDEX IF NOT EXISTS idx_sys_menu_parent_id ON sys_menu(parent_id);
 CREATE INDEX IF NOT EXISTS idx_sys_menu_status ON sys_menu(status);
 CREATE INDEX IF NOT EXISTS idx_sys_menu_deleted_at ON sys_menu(deleted_at);
 -- ============================================
 -- 字典表索引
 -- ============================================
 -- 字典类型表索引
 CREATE INDEX IF NOT EXISTS idx_sys_dict_type_dict_type ON sys_dict_type(dict_type);
 CREATE INDEX IF NOT EXISTS idx_sys_dict_type_status ON sys_dict_type(status);
@@ -57,23 +29,16 @@ CREATE INDEX IF NOT EXISTS idx_sys_dict_data_dict_value ON sys_dict_data(dict_va
 CREATE INDEX IF NOT EXISTS idx_sys_dict_data_status ON sys_dict_data(status);
 CREATE INDEX IF NOT EXISTS idx_sys_dict_data_deleted_at ON sys_dict_data(deleted_at);
-- 通用字典表索引
+-- 字典表索引
 CREATE INDEX IF NOT EXISTS idx_sys_dictionary_type ON sys_dictionary(type);
 CREATE INDEX IF NOT EXISTS idx_sys_dictionary_type_code ON sys_dictionary(type, code);
 CREATE INDEX IF NOT EXISTS idx_sys_dictionary_deleted_at ON sys_dictionary(deleted_at);
 -- ============================================
 -- 系统配置表索引
 -- ============================================
 CREATE INDEX IF NOT EXISTS idx_sys_config_config_key ON sys_config(config_key);
 CREATE INDEX IF NOT EXISTS idx_sys_config_config_type ON sys_config(config_type);
 CREATE INDEX IF NOT EXISTS idx_sys_config_deleted_at ON sys_config(deleted_at);
 -- ============================================
 -- 日志表索引
 -- ============================================
 -- 登录日志表索引
 CREATE INDEX IF NOT EXISTS idx_sys_login_log_username ON sys_login_log(username);
 CREATE INDEX IF NOT EXISTS idx_sys_login_log_ip ON sys_login_log(ip);
@@ -92,26 +57,6 @@ CREATE INDEX IF NOT EXISTS idx_operation_log_created_at ON operation_log(created
 CREATE INDEX IF NOT EXISTS idx_operation_log_status ON operation_log(status);
 CREATE INDEX IF NOT EXISTS idx_operation_log_deleted_at ON operation_log(deleted_at);
 -- 审计日志表索引
 CREATE INDEX IF NOT EXISTS idx_audit_log_entity_type ON audit_log(entity_type);
 CREATE INDEX IF NOT EXISTS idx_audit_log_entity_id ON audit_log(entity_id);
 CREATE INDEX IF NOT EXISTS idx_audit_log_operation_type ON audit_log(operation_type);
 CREATE INDEX IF NOT EXISTS idx_audit_log_operator ON audit_log(operator);
 CREATE INDEX IF NOT EXISTS idx_audit_log_operation_time ON audit_log(operation_time);
 CREATE INDEX IF NOT EXISTS idx_audit_log_entity ON audit_log(entity_type, entity_id);
 -- 审计日志归档表索引
 CREATE INDEX IF NOT EXISTS idx_audit_log_archive_entity_type ON audit_log_archive(entity_type);
 CREATE INDEX IF NOT EXISTS idx_audit_log_archive_entity_id ON audit_log_archive(entity_id);
 CREATE INDEX IF NOT EXISTS idx_audit_log_archive_operation_type ON audit_log_archive(operation_type);
 CREATE INDEX IF NOT EXISTS idx_audit_log_archive_operator ON audit_log_archive(operator);
 CREATE INDEX IF NOT EXISTS idx_audit_log_archive_operation_time ON audit_log_archive(operation_time);
 CREATE INDEX IF NOT EXISTS idx_audit_log_archive_archived_at ON audit_log_archive(archived_at);
 -- ============================================
 -- 通知与消息表索引
 -- ============================================
 -- 系统公告表索引
 CREATE INDEX IF NOT EXISTS idx_sys_notice_notice_type ON sys_notice(notice_type);
 CREATE INDEX IF NOT EXISTS idx_sys_notice_status ON sys_notice(status);
@@ -123,17 +68,11 @@ CREATE INDEX IF NOT EXISTS idx_sys_user_message_notice_id ON sys_user_message(no
 CREATE INDEX IF NOT EXISTS idx_sys_user_message_is_read ON sys_user_message(is_read);
 CREATE INDEX IF NOT EXISTS idx_sys_user_message_deleted_at ON sys_user_message(deleted_at);
 -- ============================================
 -- 文件管理表索引
 -- ============================================
 CREATE INDEX IF NOT EXISTS idx_sys_file_file_type ON sys_file(file_type);
 CREATE INDEX IF NOT EXISTS idx_sys_file_deleted_at ON sys_file(deleted_at);
 -- ============================================
 -- OAuth2客户端表索引
 -- ============================================
 CREATE INDEX IF NOT EXISTS idx_oauth2_client_client_id ON oauth2_client(client_id);
 CREATE INDEX IF NOT EXISTS idx_oauth2_client_enabled ON oauth2_client(enabled);
 CREATE INDEX IF NOT EXISTS idx_oauth2_client_deleted_at ON oauth2_client(deleted_at);
@@ -1,41 +0,0 @@
 -- 创建操作日志表
 CREATE TABLE IF NOT EXISTS sys_operation_log (
    id BIGINT PRIMARY KEY,
    username VARCHAR(50),
    operation VARCHAR(100),
    method VARCHAR(200),
    params TEXT,
    result TEXT,
    ip VARCHAR(50),
    duration BIGINT,
    status VARCHAR(1) DEFAULT '0',
    error_msg TEXT,
    create_by VARCHAR(50),
    update_by VARCHAR(50),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
 -- 创建索引
 CREATE INDEX IF NOT EXISTS idx_operation_log_username ON sys_operation_log(username);
 CREATE INDEX IF NOT EXISTS idx_operation_log_created_at ON sys_operation_log(created_at);
 CREATE INDEX IF NOT EXISTS idx_operation_log_status ON sys_operation_log(status);
 -- 添加注释
 COMMENT ON TABLE sys_operation_log IS '操作日志表';
 COMMENT ON COLUMN sys_operation_log.id IS '主键ID';
 COMMENT ON COLUMN sys_operation_log.username IS '操作用户';
 COMMENT ON COLUMN sys_operation_log.operation IS '操作描述';
 COMMENT ON COLUMN sys_operation_log.method IS '请求方法';
 COMMENT ON COLUMN sys_operation_log.params IS '请求参数';
 COMMENT ON COLUMN sys_operation_log.result IS '操作结果';
 COMMENT ON COLUMN sys_operation_log.ip IS 'IP地址';
 COMMENT ON COLUMN sys_operation_log.duration IS '执行时长(毫秒)';
 COMMENT ON COLUMN sys_operation_log.status IS '操作状态(0成功 1失败)';
 COMMENT ON COLUMN sys_operation_log.error_msg IS '错误消息';
 COMMENT ON COLUMN sys_operation_log.create_by IS '创建人';
 COMMENT ON COLUMN sys_operation_log.update_by IS '更新人';
 COMMENT ON COLUMN sys_operation_log.created_at IS '创建时间';
 COMMENT ON COLUMN sys_operation_log.updated_at IS '更新时间';
 COMMENT ON COLUMN sys_operation_log.deleted_at IS '删除时间';
@@ -0,0 +1,90 @@
 -- 系统菜单初始化数据
 -- 版本: V6
 -- 描述: 初始化系统菜单数据
 -- 一级菜单
 INSERT INTO sys_menu (id, parent_id, menu_name, order_num, menu_type, perms, component, status, created_at, updated_at) VALUES
 (1, 0, '系统管理', 1, 'M', NULL, NULL, 1, NOW(), NOW()),
 (2, 0, '审计日志', 2, 'M', NULL, NULL, 1, NOW(), NOW()),
 (3, 0, '系统监控', 3, 'M', NULL, NULL, 1, NOW(), NOW());
 -- 系统管理子菜单
 INSERT INTO sys_menu (id, parent_id, menu_name, order_num, menu_type, perms, component, status, created_at, updated_at) VALUES
 (11, 1, '用户管理', 1, 'C', 'system:user:list', 'system/user/index', 1, NOW(), NOW()),
 (12, 1, '角色管理', 2, 'C', 'system:role:list', 'system/role/index', 1, NOW(), NOW()),
 (13, 1, '菜单管理', 3, 'C', 'system:menu:list', 'system/menu/index', 1, NOW(), NOW()),
 (14, 1, '部门管理', 4, 'C', 'system:dept:list', 'system/dept/index', 1, NOW(), NOW()),
 (15, 1, '字典管理', 5, 'C', 'system:dict:list', 'system/dict/index', 1, NOW(), NOW()),
 (16, 1, '参数管理', 6, 'C', 'system:config:list', 'system/config/index', 1, NOW(), NOW()),
 (17, 1, '通知公告', 7, 'C', 'system:notice:list', 'system/notice/index', 1, NOW(), NOW()),
 (18, 1, '文件管理', 8, 'C', 'system:file:list', 'system/file/index', 1, NOW(), NOW());
 -- 用户管理按钮权限
 INSERT INTO sys_menu (id, parent_id, menu_name, order_num, menu_type, perms, component, status, created_at, updated_at) VALUES
 (111, 11, '用户查询', 1, 'F', 'system:user:query', NULL, 1, NOW(), NOW()),
 (112, 11, '用户新增', 2, 'F', 'system:user:add', NULL, 1, NOW(), NOW()),
 (113, 11, '用户修改', 3, 'F', 'system:user:edit', NULL, 1, NOW(), NOW()),
 (114, 11, '用户删除', 4, 'F', 'system:user:remove', NULL, 1, NOW(), NOW()),
 (115, 11, '用户导出', 5, 'F', 'system:user:export', NULL, 1, NOW(), NOW()),
 (116, 11, '用户导入', 6, 'F', 'system:user:import', NULL, 1, NOW(), NOW()),
 (117, 11, '重置密码', 7, 'F', 'system:user:resetPwd', NULL, 1, NOW(), NOW());
 -- 角色管理按钮权限
 INSERT INTO sys_menu (id, parent_id, menu_name, order_num, menu_type, perms, component, status, created_at, updated_at) VALUES
 (121, 12, '角色查询', 1, 'F', 'system:role:query', NULL, 1, NOW(), NOW()),
 (122, 12, '角色新增', 2, 'F', 'system:role:add', NULL, 1, NOW(), NOW()),
 (123, 12, '角色修改', 3, 'F', 'system:role:edit', NULL, 1, NOW(), NOW()),
 (124, 12, '角色删除', 4, 'F', 'system:role:remove', NULL, 1, NOW(), NOW()),
 (125, 12, '角色导出', 5, 'F', 'system:role:export', NULL, 1, NOW(), NOW());
 -- 菜单管理按钮权限
 INSERT INTO sys_menu (id, parent_id, menu_name, order_num, menu_type, perms, component, status, created_at, updated_at) VALUES
 (131, 13, '菜单查询', 1, 'F', 'system:menu:query', NULL, 1, NOW(), NOW()),
 (132, 13, '菜单新增', 2, 'F', 'system:menu:add', NULL, 1, NOW(), NOW()),
 (133, 13, '菜单修改', 3, 'F', 'system:menu:edit', NULL, 1, NOW(), NOW()),
 (134, 13, '菜单删除', 4, 'F', 'system:menu:remove', NULL, 1, NOW(), NOW());
 -- 审计日志子菜单
 INSERT INTO sys_menu (id, parent_id, menu_name, order_num, menu_type, perms, component, status, created_at, updated_at) VALUES
 (21, 2, '操作日志', 1, 'C', 'audit:operation:list', 'audit/operation/index', 1, NOW(), NOW()),
 (22, 2, '登录日志', 2, 'C', 'audit:login:list', 'audit/login/index', 1, NOW(), NOW()),
 (23, 2, '异常日志', 3, 'C', 'audit:exception:list', 'audit/exception/index', 1, NOW(), NOW());
 -- 操作日志按钮权限
 INSERT INTO sys_menu (id, parent_id, menu_name, order_num, menu_type, perms, component, status, created_at, updated_at) VALUES
 (211, 21, '操作查询', 1, 'F', 'audit:operation:query', NULL, 1, NOW(), NOW()),
 (212, 21, '操作删除', 2, 'F', 'audit:operation:remove', NULL, 1, NOW(), NOW()),
 (213, 21, '操作导出', 3, 'F', 'audit:operation:export', NULL, 1, NOW(), NOW());
 -- 登录日志按钮权限
 INSERT INTO sys_menu (id, parent_id, menu_name, order_num, menu_type, perms, component, status, created_at, updated_at) VALUES
 (221, 22, '登录查询', 1, 'F', 'audit:login:query', NULL, 1, NOW(), NOW()),
 (222, 22, '登录删除', 2, 'F', 'audit:login:remove', NULL, 1, NOW(), NOW()),
 (223, 22, '登录导出', 3, 'F', 'audit:login:export', NULL, 1, NOW(), NOW());
 -- 异常日志按钮权限
 INSERT INTO sys_menu (id, parent_id, menu_name, order_num, menu_type, perms, component, status, created_at, updated_at) VALUES
 (231, 23, '异常查询', 1, 'F', 'audit:exception:query', NULL, 1, NOW(), NOW()),
 (232, 23, '异常删除', 2, 'F', 'audit:exception:remove', NULL, 1, NOW(), NOW()),
 (233, 23, '异常导出', 3, 'F', 'audit:exception:export', NULL, 1, NOW(), NOW());
 -- 系统监控子菜单
 INSERT INTO sys_menu (id, parent_id, menu_name, order_num, menu_type, perms, component, status, created_at, updated_at) VALUES
 (31, 3, '在线用户', 1, 'C', 'monitor:online:list', 'monitor/online/index', 1, NOW(), NOW()),
 (32, 3, '定时任务', 2, 'C', 'monitor:job:list', 'monitor/job/index', 1, NOW(), NOW()),
 (33, 3, '数据监控', 3, 'C', 'monitor:data:list', 'monitor/data/index', 1, NOW(), NOW()),
 (34, 3, '服务监控', 4, 'C', 'monitor:server:list', 'monitor/server/index', 1, NOW(), NOW()),
 (35, 3, '缓存监控', 5, 'C', 'monitor:cache:list', 'monitor/cache/index', 1, NOW(), NOW());
 -- 在线用户按钮权限
 INSERT INTO sys_menu (id, parent_id, menu_name, order_num, menu_type, perms, component, status, created_at, updated_at) VALUES
 (311, 31, '在线查询', 1, 'F', 'monitor:online:query', NULL, 1, NOW(), NOW()),
 (312, 31, '在线强退', 2, 'F', 'monitor:online:forceLogout', NULL, 1, NOW(), NOW());
 -- 定时任务按钮权限
 INSERT INTO sys_menu (id, parent_id, menu_name, order_num, menu_type, perms, component, status, created_at, updated_at) VALUES
 (321, 32, '任务查询', 1, 'F', 'monitor:job:query', NULL, 1, NOW(), NOW()),
 (322, 32, '任务新增', 2, 'F', 'monitor:job:add', NULL, 1, NOW(), NOW()),
 (323, 32, '任务修改', 3, 'F', 'monitor:job:edit', NULL, 1, NOW(), NOW()),
 (324, 32, '任务删除', 4, 'F', 'monitor:job:remove', NULL, 1, NOW(), NOW()),
 (325, 32, '任务执行', 5, 'F', 'monitor:job:execute', NULL, 1, NOW(), NOW());
@@ -0,0 +1,40 @@
 -- Novalon管理系统审计日志表
 -- 版本: V7
 -- 描述: 创建审计日志表，记录数据变更前后的完整对比
 CREATE TABLE IF NOT EXISTS audit_log (
    id BIGSERIAL PRIMARY KEY,
    entity_type VARCHAR(100) NOT NULL,
    entity_id BIGINT,
    operation_type VARCHAR(20) NOT NULL,
    operator VARCHAR(100),
    operation_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    before_data JSONB,
    after_data JSONB,
    changed_fields TEXT [],
    ip_address VARCHAR(50),
    user_agent TEXT,
    description TEXT,
    create_by VARCHAR(50),
    update_by VARCHAR(50),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    deleted_at TIMESTAMP
 );
 CREATE INDEX idx_audit_log_entity_type ON audit_log(entity_type);
 CREATE INDEX idx_audit_log_entity_id ON audit_log(entity_id);
 CREATE INDEX idx_audit_log_operation_type ON audit_log(operation_type);
 CREATE INDEX idx_audit_log_operator ON audit_log(operator);
 CREATE INDEX idx_audit_log_operation_time ON audit_log(operation_time);
 CREATE INDEX idx_audit_log_entity ON audit_log(entity_type, entity_id);
 COMMENT ON TABLE audit_log IS '审计日志表';
 COMMENT ON COLUMN audit_log.id IS '主键ID';
 COMMENT ON COLUMN audit_log.entity_type IS '实体类型（如User, Role等）';
 COMMENT ON COLUMN audit_log.entity_id IS '实体ID';
 COMMENT ON COLUMN audit_log.operation_type IS '操作类型（CREATE, UPDATE, DELETE）';
 COMMENT ON COLUMN audit_log.operator IS '操作人';
 COMMENT ON COLUMN audit_log.operation_time IS '操作时间';
 COMMENT ON COLUMN audit_log.before_data IS '变更前数据（JSON格式）';
 COMMENT ON COLUMN audit_log.after_data IS '变更后数据（JSON格式）';
 COMMENT ON COLUMN audit_log.changed_fields IS '变更字段列表';
 COMMENT ON COLUMN audit_log.ip_address IS 'IP地址';COMMENT ON COLUMN audit_log.description IS '操作描述';
 COMMENT ON COLUMN audit_log.created_at IS '记录创建时间';
@@ -0,0 +1,43 @@
 -- Novalon管理系统审计日志归档表
 -- 版本: V8
 -- 描述: 创建审计日志归档表，用于存储历史审计日志
 CREATE TABLE IF NOT EXISTS audit_log_archive (
    id BIGSERIAL PRIMARY KEY,
    entity_type VARCHAR(100) NOT NULL,
    entity_id BIGINT,
    operation_type VARCHAR(20) NOT NULL,
    operator VARCHAR(100),
    operation_time TIMESTAMP,
    before_data JSONB,
    after_data JSONB,
    changed_fields TEXT[],
    ip_address VARCHAR(50),
    user_agent TEXT,
    description TEXT,
    created_at TIMESTAMP,
    archived_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
 );
 CREATE INDEX idx_audit_log_archive_entity_type ON audit_log_archive(entity_type);
 CREATE INDEX idx_audit_log_archive_entity_id ON audit_log_archive(entity_id);
 CREATE INDEX idx_audit_log_archive_operation_type ON audit_log_archive(operation_type);
 CREATE INDEX idx_audit_log_archive_operator ON audit_log_archive(operator);
 CREATE INDEX idx_audit_log_archive_operation_time ON audit_log_archive(operation_time);
 CREATE INDEX idx_audit_log_archive_archived_at ON audit_log_archive(archived_at);
 COMMENT ON TABLE audit_log_archive IS '审计日志归档表';
 COMMENT ON COLUMN audit_log_archive.id IS '主键ID';
 COMMENT ON COLUMN audit_log_archive.entity_type IS '实体类型（如User, Role等）';
 COMMENT ON COLUMN audit_log_archive.entity_id IS '实体ID';
 COMMENT ON COLUMN audit_log_archive.operation_type IS '操作类型（CREATE, UPDATE, DELETE）';
 COMMENT ON COLUMN audit_log_archive.operator IS '操作人';
 COMMENT ON COLUMN audit_log_archive.operation_time IS '操作时间';
 COMMENT ON COLUMN audit_log_archive.before_data IS '变更前数据（JSON格式）';
 COMMENT ON COLUMN audit_log_archive.after_data IS '变更后数据（JSON格式）';
 COMMENT ON COLUMN audit_log_archive.changed_fields IS '变更字段列表';
 COMMENT ON COLUMN audit_log_archive.ip_address IS 'IP地址';
 COMMENT ON COLUMN audit_log_archive.user_agent IS '用户代理';
 COMMENT ON COLUMN audit_log_archive.description IS '操作描述';
 COMMENT ON COLUMN audit_log_archive.created_at IS '记录创建时间';
 COMMENT ON COLUMN audit_log_archive.archived_at IS '归档时间';
@@ -1,5 +1,5 @@
 -- Novalon管理系统权限授予脚本
-- 版本: V4
+-- 版本: V9
 -- 描述: 为novalon用户授予所有表的访问权限
 -- 授予所有表的SELECT, INSERT, UPDATE, DELETE权限
@@ -2,84 +2,186 @@ package cn.novalon.gym.manage.sys.audit;
 import cn.novalon.gym.manage.sys.audit.domain.AuditLog;
 import cn.novalon.gym.manage.sys.audit.service.IAuditLogService;
 import com.fasterxml.jackson.annotation.JsonIdentityInfo;
 import com.fasterxml.jackson.annotation.ObjectIdGenerators;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.SerializationFeature;
 import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
 import org.aspectj.lang.ProceedingJoinPoint;
 import org.aspectj.lang.annotation.Around;
 import org.aspectj.lang.annotation.Aspect;
 import org.aspectj.lang.annotation.Before;
 import org.aspectj.lang.reflect.MethodSignature;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.data.domain.Persistable;
 import org.springframework.security.core.context.ReactiveSecurityContextHolder;
 import org.springframework.stereotype.Component;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import java.util.ArrayList;
 import java.util.List;
 /**
 * 审计日志切面
 * 
 * 文件定义：使用AOP自动拦截Repository操作，记录审计日志
 * 涉及业务：自动记录所有数据变更操作，包括变更前后对比
 * 算法：使用异步方式记录日志，不阻塞主流程
 * 
 * @author 张翔
 * @date 2026-04-01
 */
@Aspect
@Component
@Deprecated
 public class AuditLogAspect {
    private static final Logger logger = LoggerFactory.getLogger(AuditLogAspect.class);
    private final IAuditLogService auditLogService;
    private final ObjectMapper objectMapper;
-    public AuditLogAspect(IAuditLogService auditLogService) {
+    public AuditLogAspect(IAuditLogService auditLogService, ObjectMapper objectMapper) {
        this.auditLogService = auditLogService;
-        logger.info("=== AuditLogAspect 初始化完成 ===");
+        this.objectMapper = new ObjectMapper()
                .registerModule(new JavaTimeModule())
                .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
                .disable(SerializationFeature.FAIL_ON_SELF_REFERENCES);
    }
-    @Before("execution(* cn.novalon.gym.manage.sys.core.service.impl.SysUserService.createUser(..))")
+    @Around("(execution(* cn.novalon.gym.manage.db.repository.*Repository.save(..)) || " +
-    public void testAopWorking() {
+            "execution(* cn.novalon.gym.manage.db.repository.*Repository.delete(..)) || " +
-        logger.info("=== AuditLogAspect @Before 测试: SysUserService.createUser 被调用 ===");
+            "execution(* cn.novalon.gym.manage.db.repository.*Repository.deleteById(..))) && " +
-    }
+            "!execution(* cn.novalon.gym.manage.db.repository.AuditLogRepository.*(..)) && " +
-
+            "!execution(* cn.novalon.gym.manage.db.dao.AuditLogDao.*(..))")
-    @Around("@annotation(auditable)")
+    public Object logAuditEvent(ProceedingJoinPoint joinPoint) throws Throwable {
-    public Object logAuditEvent(ProceedingJoinPoint joinPoint, Auditable auditable) throws Throwable {
+        String methodName = joinPoint.getSignature().getName();
        String methodName = ((MethodSignature) joinPoint.getSignature()).getName();
        String className = joinPoint.getTarget().getClass().getSimpleName();
-        String entityType = auditable.entityType();
+        Object[] args = joinPoint.getArgs();
        String operationType = auditable.operationType();
-        logger.debug("审计切面拦截: {}.{}(), entityType={}, operationType={}", className, methodName, entityType, operationType);
+        String operationType = determineOperationType(methodName);
        String entityType = extractEntityType(className);
        logger.debug("拦截审计操作: {}.{}, 操作类型: {}, 实体类型: {}", 
                    className, methodName, operationType, entityType);
        try {
            if ("save".equals(methodName) && args.length > 0) {
                return handleSaveOperation(joinPoint, args[0], entityType, operationType);
            } else if ("delete".equals(methodName) || "deleteById".equals(methodName)) {
                return handleDeleteOperation(joinPoint, args, entityType, operationType);
            }
            return joinPoint.proceed();
        } catch (Throwable error) {
            logger.error("审计日志记录失败: {}", error.getMessage(), error);
            throw error;
        }
    }
    private Object handleSaveOperation(ProceedingJoinPoint joinPoint, Object entity, 
                                       String entityType, String operationType) throws Throwable {
        String entityClassName = entity.getClass().getSimpleName();
        if (entityClassName.contains("AuditLog") || entityClassName.contains("AuditLogEntity")) {
            logger.debug("跳过审计日志实体的审计记录: {}", entityClassName);
            return joinPoint.proceed();
        }
        try {
            final String[] beforeDataHolder = {null};
            final Long[] entityIdHolder = {null};
            final String[] operationTypeHolder = {operationType};
            if (entity instanceof Persistable) {
                Persistable<?> persistable = (Persistable<?>) entity;
                entityIdHolder[0] = persistable.getId() != null ? 
                          ((Number) persistable.getId()).longValue() : null;
                if (entityIdHolder[0] != null) {
                    beforeDataHolder[0] = fetchEntityBeforeData(entityType, entityIdHolder[0]);
                    operationTypeHolder[0] = "UPDATE";
                } else {
                    operationTypeHolder[0] = "CREATE";
                }
            }
            Object result = joinPoint.proceed();
            if (result instanceof Mono) {
-                return ((Mono<Object>) result).flatMap(retValue -> {
+                return ((Mono<?>) result).flatMap(savedEntity -> {
-                    Long entityId = extractIdFromResult(retValue);
+                    String afterData = serializeEntity(savedEntity);
-                    String afterData = serializeEntity(retValue);
+                    Long finalEntityId = entityIdHolder[0] != null ? entityIdHolder[0] : extractEntityId(savedEntity);
                    String finalOperationType = operationTypeHolder[0];
                    String finalBeforeData = beforeDataHolder[0];
                    logger.debug("保存操作审计日志: entityType={}, entityIdHolder={}, extractedEntityId={}, finalEntityId={}", 
                            entityType, entityIdHolder[0], extractEntityId(savedEntity), finalEntityId);
                    return createAndSaveAuditLog(
-                            entityType, entityId, operationType,
+                        entityType, finalEntityId, finalOperationType, 
-                            null, afterData
+                        finalBeforeData, afterData, savedEntity
-                    ).thenReturn(retValue);
+                    ).thenReturn(savedEntity);
                });
            } else if (result instanceof Flux) {
                return ((Flux<Object>) result).collectList()
                        .flatMapMany(list -> {
                            String afterData = serializeEntity(list);
                            return createAndSaveAuditLog(
                                    entityType, null, operationType,
                                    null, afterData
                            ).thenMany(Flux.fromIterable(list));
                        });
            }
            return result;
        } catch (Throwable error) {
-            logger.error("审计日志记录失败: {}.{}()", className, methodName, error);
+            logger.error("保存操作审计日志记录失败", error);
            throw error;
        }
    }
    private Object handleDeleteOperation(ProceedingJoinPoint joinPoint, Object[] args,
                                         String entityType, String operationType) throws Throwable {
        try {
            Long entityId = null;
            String beforeData = null;
            if (args.length > 0) {
                if (args[0] instanceof Number) {
                    entityId = ((Number) args[0]).longValue();
                    beforeData = fetchEntityBeforeData(entityType, entityId);
                } else if (args[0] instanceof Persistable) {
                    Persistable<?> persistable = (Persistable<?>) args[0];
                    entityId = persistable.getId() != null ? 
                              ((Number) persistable.getId()).longValue() : null;
                    beforeData = serializeEntity(args[0]);
                }
            }
            Object result = joinPoint.proceed();
            if (result instanceof Mono) {
                Long finalEntityId = entityId;
                String finalBeforeData = beforeData;
                return ((Mono<?>) result).flatMap(deleted -> 
                    createAndSaveAuditLog(
                        entityType, finalEntityId, "DELETE", 
                        finalBeforeData, null, null
                    ).thenReturn(deleted)
                );
            } else if (result instanceof Flux) {
                Long finalEntityId = entityId;
                String finalBeforeData = beforeData;
                return ((Flux<?>) result).flatMap(deleted ->
                    createAndSaveAuditLog(
                        entityType, finalEntityId, "DELETE", 
                        finalBeforeData, null, null
                    ).thenReturn(deleted)
                );
            }
            return result;
        } catch (Throwable error) {
            logger.error("删除操作审计日志记录失败", error);
            throw error;
        }
    }
    private Mono<Void> createAndSaveAuditLog(String entityType, Long entityId, 
                                             String operationType, String beforeData, 
-                                             String afterData) {
+                                             String afterData, Object entity) {
        logger.debug("创建审计日志: entityType={}, entityId={}, operationType={}", entityType, entityId, operationType);
        return ReactiveSecurityContextHolder.getContext()
                .map(ctx -> ctx.getAuthentication().getPrincipal())
                .defaultIfEmpty("system")
@@ -91,12 +193,22 @@ public class AuditLogAspect {
                    auditLog.setOperator(principal instanceof String ? (String) principal : "system");
                    auditLog.setBeforeData(beforeData);
                    auditLog.setAfterData(afterData);
                    logger.debug("审计日志对象: entityId={}, entityType={}, operationType={}", 
                            auditLog.getEntityId(), auditLog.getEntityType(), auditLog.getOperationType());
                    if (beforeData != null && afterData != null) {
                        String[] changedFields = extractChangedFields(beforeData, afterData);
                        auditLog.setChangedFields(changedFields);
                    }
                    auditLog.setDescription(generateDescription(entityType, operationType, entityId));
-                    return auditLogService.saveAsync(auditLog)
+                    return auditLogService.save(auditLog)
-                            .doOnSuccess(saved -> logger.debug("审计日志保存成功: {} - {}, ID={}",
+                            .doOnSuccess(saved -> logger.debug("审计日志保存成功: {} - {}", 
-                                    entityType, operationType, saved.getId()))
+                                    entityType, operationType))
-                            .doOnError(error -> logger.error("审计日志保存失败: {}", error.getMessage()))
+                            .doOnError(error -> logger.error("审计日志保存失败: {}", 
                                    error.getMessage()))
                            .then();
                })
                .onErrorResume(error -> {
@@ -105,53 +217,99 @@ public class AuditLogAspect {
                });
    }
-    private Long extractIdFromResult(Object result) {
+    private String determineOperationType(String methodName) {
-        if (result == null) {
+        if (methodName.startsWith("save")) {
-            return null;
+            return "SAVE";
        } else if (methodName.startsWith("delete")) {
            return "DELETE";
        }
-        try {
+        return "UNKNOWN";
-            var getIdMethod = result.getClass().getMethod("getId");
+    }
-            Object id = getIdMethod.invoke(result);
+
-            if (id instanceof Number) {
+    private String extractEntityType(String className) {
-                return ((Number) id).longValue();
+        if (className.contains("User")) {
-            }
+            return "User";
-            if (id instanceof String) {
+        } else if (className.contains("Role")) {
-                try {
+            return "Role";
-                    return Long.parseLong((String) id);
+        } else if (className.contains("Menu")) {
-                } catch (NumberFormatException e) {
+            return "Menu";
-                    return null;
+        } else if (className.contains("Permission")) {
-                }
+            return "Permission";
            }
        } catch (NoSuchMethodException e) {
            logger.debug("结果对象没有getId方法: {}", result.getClass().getSimpleName());
        } catch (Exception e) {
            logger.debug("提取结果ID失败: {}", e.getMessage());
        }
        return className.replace("Repository", "").replace("Impl", "");
    }
    private String fetchEntityBeforeData(String entityType, Long entityId) {
        return null;
    }
    private String serializeEntity(Object entity) {
        try {
-            ObjectMapper mapper = new ObjectMapper()
+            return objectMapper.writeValueAsString(entity);
                    .registerModule(new JavaTimeModule())
                    .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
                    .disable(SerializationFeature.FAIL_ON_SELF_REFERENCES);
            return mapper.writeValueAsString(entity);
        } catch (Exception e) {
            logger.error("序列化实体失败: {}", e.getMessage());
            return null;
        }
    }
    private Long extractEntityId(Object entity) {
        logger.debug("提取实体ID: entity class={}", entity.getClass().getName());
        if (entity instanceof Persistable) {
            Persistable<?> persistable = (Persistable<?>) entity;
            Object id = persistable.getId();
            logger.debug("Persistable实体ID: id={}, isNew={}", id, persistable.isNew());
            return id != null ? ((Number) id).longValue() : null;
        }
        logger.debug("实体不是Persistable类型");
        return null;
    }
    private String[] extractChangedFields(String beforeData, String afterData) {
        try {
            JsonNode beforeNode = objectMapper.readTree(beforeData);
            JsonNode afterNode = objectMapper.readTree(afterData);
            List<String> changedFields = new ArrayList<>();
            beforeNode.fieldNames().forEachRemaining(fieldName -> {
                JsonNode beforeValue = beforeNode.get(fieldName);
                JsonNode afterValue = afterNode.get(fieldName);
                if (afterValue == null || !beforeValue.equals(afterValue)) {
                    changedFields.add(fieldName);
                }
            });
            afterNode.fieldNames().forEachRemaining(fieldName -> {
                if (!beforeNode.has(fieldName)) {
                    changedFields.add(fieldName);
                }
            });
            return changedFields.toArray(new String[0]);
        } catch (Exception e) {
            logger.error("提取变更字段失败: {}", e.getMessage());
            return new String[0];
        }
    }
    private String generateDescription(String entityType, String operationType, Long entityId) {
-        String operation = switch (operationType) {
+        String operation = "";
-            case "CREATE" -> "创建";
+        switch (operationType) {
-            case "UPDATE" -> "更新";
+            case "CREATE":
-            case "DELETE" -> "删除";
+                operation = "创建";
-            default -> "操作";
+                break;
-        };
+            case "UPDATE":
                operation = "更新";
                break;
            case "DELETE":
                operation = "删除";
                break;
            default:
                operation = "操作";
        }
        return String.format("%s%s (ID: %s)", operation, entityType, 
-                entityId != null ? entityId : "未知");
+                            entityId != null ? entityId : "未知");
    }
 }
@@ -1,80 +0,0 @@
 package cn.novalon.gym.manage.sys.audit;
 import cn.novalon.gym.manage.sys.audit.domain.AuditLog;
 import cn.novalon.gym.manage.sys.audit.service.IAuditLogService;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.SerializationFeature;
 import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.security.core.context.ReactiveSecurityContextHolder;
 import reactor.core.publisher.Mono;
 public final class AuditLogHelper {
    private static final Logger logger = LoggerFactory.getLogger(AuditLogHelper.class);
    private static final ObjectMapper objectMapper = new ObjectMapper()
            .registerModule(new JavaTimeModule())
            .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
            .disable(SerializationFeature.FAIL_ON_SELF_REFERENCES);
    private AuditLogHelper() {}
    public static Mono<Void> record(IAuditLogService auditLogService,
                                    String entityType, Long entityId,
                                    String operationType, Object afterEntity) {
        return record(auditLogService, entityType, entityId, operationType, null, afterEntity);
    }
    public static Mono<Void> record(IAuditLogService auditLogService,
                                    String entityType, Long entityId,
                                    String operationType, Object beforeEntity, Object afterEntity) {
        return ReactiveSecurityContextHolder.getContext()
                .map(ctx -> ctx.getAuthentication().getPrincipal())
                .defaultIfEmpty("system")
                .flatMap(principal -> {
                    AuditLog auditLog = new AuditLog();
                    auditLog.generateId();
                    auditLog.setEntityType(entityType);
                    auditLog.setEntityId(entityId != null ? entityId : 0L);
                    auditLog.setOperationType(operationType);
                    auditLog.setOperator(principal instanceof String ? (String) principal : "system");
                    auditLog.setBeforeData(serializeEntity(beforeEntity));
                    auditLog.setAfterData(serializeEntity(afterEntity));
                    auditLog.setDescription(generateDescription(entityType, operationType, entityId));
                    logger.info("记录审计日志: {} {} ID={}, operator={}", operationType, entityType, entityId, auditLog.getOperator());
                    return auditLogService.saveAsync(auditLog)
                            .doOnSuccess(saved -> logger.info("审计日志保存成功: {} - {}, ID={}",
                                    entityType, operationType, saved.getId()))
                            .doOnError(error -> logger.error("审计日志保存失败: {}", error.getMessage()))
                            .then();
                })
                .onErrorResume(error -> {
                    logger.error("记录审计日志失败，但不影响主流程: {}", error.getMessage(), error);
                    return Mono.empty();
                });
    }
    private static String serializeEntity(Object entity) {
        try {
            if (entity == null) return null;
            return objectMapper.writeValueAsString(entity);
        } catch (Exception e) {
            logger.error("序列化实体失败: {}", e.getMessage());
            return null;
        }
    }
    private static String generateDescription(String entityType, String operationType, Long entityId) {
        String operation = switch (operationType) {
            case "CREATE" -> "创建";
            case "UPDATE" -> "更新";
            case "DELETE" -> "删除";
            default -> "操作";
        };
        return String.format("%s%s (ID: %s)", operation, entityType,
                entityId != null ? entityId : "未知");
    }
 }
@@ -1,15 +0,0 @@
 package cn.novalon.gym.manage.sys.audit;
 import java.lang.annotation.*;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
 public @interface Auditable {
    String entityType();
    String operationType() default "CREATE";
    String description() default "";
 }
@@ -1,181 +0,0 @@
 package cn.novalon.gym.manage.sys.audit;
 import cn.novalon.gym.manage.sys.core.domain.OperationLog;
 import cn.novalon.gym.manage.sys.core.service.IOperationLogService;
 import cn.novalon.gym.manage.sys.util.IpUtils;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import jakarta.annotation.PostConstruct;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.core.Ordered;
 import org.springframework.core.annotation.Order;
 import org.springframework.core.io.buffer.DataBufferUtils;
 import org.springframework.http.HttpMethod;
 import org.springframework.http.server.reactive.ServerHttpRequest;
 import org.springframework.security.core.context.ReactiveSecurityContextHolder;
 import org.springframework.stereotype.Component;
 import org.springframework.web.reactive.function.server.HandlerStrategies;
 import org.springframework.web.reactive.function.server.RouterFunction;
 import org.springframework.web.reactive.function.server.ServerResponse;
 import org.springframework.web.server.ServerWebExchange;
 import org.springframework.web.server.WebFilter;
 import org.springframework.web.server.WebFilterChain;
 import reactor.core.publisher.Mono;
 import java.nio.charset.StandardCharsets;
 import java.time.LocalDateTime;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
@Component
@Order(Ordered.LOWEST_PRECEDENCE)
 public class OperationLogWebFilter implements WebFilter {
    private static final Logger logger = LoggerFactory.getLogger(OperationLogWebFilter.class);
    private final IOperationLogService operationLogService;
    private final ObjectMapper objectMapper;
    private static final Map<String, OperationInfo> OPERATION_MAPPING = new ConcurrentHashMap<>();
    static {
        OPERATION_MAPPING.put("POST:/api/roles", new OperationInfo("角色管理", "创建角色"));
        OPERATION_MAPPING.put("PUT:/api/roles/", new OperationInfo("角色管理", "更新角色"));
        OPERATION_MAPPING.put("DELETE:/api/roles/", new OperationInfo("角色管理", "删除角色"));
        OPERATION_MAPPING.put("POST:/api/users", new OperationInfo("用户管理", "创建用户"));
        OPERATION_MAPPING.put("PUT:/api/users/", new OperationInfo("用户管理", "更新用户"));
        OPERATION_MAPPING.put("DELETE:/api/users/", new OperationInfo("用户管理", "删除用户"));
        OPERATION_MAPPING.put("POST:/api/users/", new OperationInfo("用户管理", "用户操作"));
        OPERATION_MAPPING.put("POST:/api/menus", new OperationInfo("菜单管理", "创建菜单"));
        OPERATION_MAPPING.put("PUT:/api/menus/", new OperationInfo("菜单管理", "更新菜单"));
        OPERATION_MAPPING.put("DELETE:/api/menus/", new OperationInfo("菜单管理", "删除菜单"));
    }
    public OperationLogWebFilter(IOperationLogService operationLogService, ObjectMapper objectMapper) {
        logger.info("=== OperationLogWebFilter 构造函数被调用 ===");
        this.operationLogService = operationLogService;
        this.objectMapper = objectMapper;
    }
    @PostConstruct
    public void init() {
        logger.info("=== OperationLogWebFilter 初始化 ===");
        logger.info("操作日志映射配置数量: {}", OPERATION_MAPPING.size());
        OPERATION_MAPPING.forEach((key, value) -> {
            logger.info("  {} -> {}:{}", key, value.module, value.operation);
        });
    }
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        String method = request.getMethod().name();
        String path = request.getPath().value();
        logger.info("WebFilter 拦截请求: {} {}", method, path);
        OperationInfo operationInfo = findOperationInfo(method, path);
        if (operationInfo == null) {
            logger.info("未匹配到操作日志配置，跳过: {} {}", method, path);
            return chain.filter(exchange);
        }
        logger.info("匹配到操作日志配置: {} {} -> {}:{}", method, path, operationInfo.module, operationInfo.operation);
        long startTime = System.currentTimeMillis();
        String ip = IpUtils.getClientIp(request);
        return Mono.deferContextual(contextView -> {
            return chain.filter(exchange)
                    .then(Mono.defer(() -> {
                        long duration = System.currentTimeMillis() - startTime;
                        logger.info("请求处理完成，准备保存操作日志: {} {}, 耗时: {}ms", method, path, duration);
                        return ReactiveSecurityContextHolder.getContext()
                                .flatMap(securityContext -> {
                                    Object principal = securityContext.getAuthentication().getPrincipal();
                                    String username = principal instanceof String ? (String) principal : "system";
                                    logger.info("获取到用户名: {}", username);
                                    return Mono.just(username);
                                })
                                .defaultIfEmpty("system")
                                .flatMap(username -> {
                                    logger.info("开始保存操作日志: 用户={}, 操作={}", username,
                                            operationInfo.module + " - " + operationInfo.operation);
                                    OperationLog log = new OperationLog();
                                    log.setUsername(username);
                                    log.setOperation(operationInfo.module + " - " + operationInfo.operation);
                                    log.setMethod(method + " " + path);
                                    log.setParams(null);
                                    log.setIp(ip);
                                    log.setDuration(duration);
                                    log.setStatus("0");
                                    return operationLogService.save(log)
                                            .doOnSuccess(saved -> logger.info("操作日志保存成功: {} - {}",
                                                    operationInfo.module, operationInfo.operation))
                                            .doOnError(e -> logger.error("操作日志保存失败: {}", e.getMessage(), e))
                                            .onErrorResume(e -> Mono.empty());
                                })
                                .then();
                    }))
                    .onErrorResume(error -> {
                        long duration = System.currentTimeMillis() - startTime;
                        logger.error("请求处理失败: {} {}, 错误: {}", method, path, error.getMessage());
                        return ReactiveSecurityContextHolder.getContext()
                                .flatMap(securityContext -> {
                                    Object principal = securityContext.getAuthentication().getPrincipal();
                                    String username = principal instanceof String ? (String) principal : "system";
                                    return Mono.just(username);
                                })
                                .defaultIfEmpty("system")
                                .flatMap(username -> {
                                    OperationLog log = new OperationLog();
                                    log.setUsername(username);
                                    log.setOperation(operationInfo.module + " - " + operationInfo.operation);
                                    log.setMethod(method + " " + path);
                                    log.setParams(null);
                                    log.setIp(ip);
                                    log.setDuration(duration);
                                    log.setStatus("1");
                                    log.setErrorMsg(error.getMessage());
                                    return operationLogService.save(log)
                                            .doOnError(e -> logger.error("错误日志保存失败: {}", e.getMessage()))
                                            .onErrorResume(e -> Mono.empty());
                                })
                                .then(Mono.error(error));
                    });
        });
    }
    private OperationInfo findOperationInfo(String method, String path) {
        String key = method + ":" + path;
        if (OPERATION_MAPPING.containsKey(key)) {
            return OPERATION_MAPPING.get(key);
        }
        for (Map.Entry<String, OperationInfo> entry : OPERATION_MAPPING.entrySet()) {
            String mappingKey = entry.getKey();
            if (key.startsWith(mappingKey)) {
                return entry.getValue();
            }
        }
        return null;
    }
    private static class OperationInfo {
        final String module;
        final String operation;
        OperationInfo(String module, String operation) {
            this.module = module;
            this.operation = operation;
        }
    }
 }
@@ -39,7 +39,7 @@ public class AuditLogArchiveService implements IAuditLogArchiveService {
    }
    @Override
-    @Transactional(transactionManager = "connectionFactoryTransactionManager")
+    @Transactional
    public Mono<Long> archiveOldLogs(int daysToKeep) {
        LocalDateTime archiveBefore = LocalDateTime.now().minusDays(daysToKeep);
@@ -53,7 +53,7 @@ public class AuditLogArchiveService implements IAuditLogArchiveService {
    }
    @Override
-    @Transactional(transactionManager = "connectionFactoryTransactionManager")
+    @Transactional
    public Mono<AuditLogArchive> archiveLog(AuditLog auditLog) {
        AuditLogArchive archive = convertToArchive(auditLog);
@@ -99,7 +99,7 @@ public class AuditLogArchiveService implements IAuditLogArchiveService {
    }
    @Override
-    @Transactional(transactionManager = "connectionFactoryTransactionManager")
+    @Transactional
    public Mono<Void> deleteArchivedLogsOlderThan(LocalDateTime date) {
        return auditLogArchiveRepository.findByOperationTimeBetween(LocalDateTime.MIN, date)
                .flatMap(archive -> auditLogArchiveRepository.deleteById(archive.getId()))
@@ -160,13 +160,13 @@ public class AuditLogService implements IAuditLogService {
    }
    @Override
-    @Transactional(transactionManager = "connectionFactoryTransactionManager")
+    @Transactional
    public Mono<Void> deleteById(Long id) {
        return auditLogRepository.deleteById(id);
    }
    @Override
-    @Transactional(transactionManager = "connectionFactoryTransactionManager")
+    @Transactional
    public Mono<Void> logicalDeleteById(Long id) {
        return auditLogRepository.findById(id)
                .flatMap(auditLog -> {
@@ -177,7 +177,7 @@ public class AuditLogService implements IAuditLogService {
    }
    @Override
-    @Transactional(transactionManager = "connectionFactoryTransactionManager")
+    @Transactional
    public Mono<Void> logicalDeleteByIds(List<Long> ids) {
        return Flux.fromIterable(ids)
                .flatMap(this::logicalDeleteById)
@@ -185,7 +185,7 @@ public class AuditLogService implements IAuditLogService {
    }
    @Override
-    @Transactional(transactionManager = "connectionFactoryTransactionManager")
+    @Transactional
    public Mono<Void> restoreById(Long id) {
        return auditLogRepository.findById(id)
                .flatMap(auditLog -> {
@@ -196,7 +196,7 @@ public class AuditLogService implements IAuditLogService {
    }
    @Override
-    @Transactional(transactionManager = "connectionFactoryTransactionManager")
+    @Transactional
    public Mono<Void> restoreByIds(List<Long> ids) {
        return Flux.fromIterable(ids)
                .flatMap(this::restoreById)
@@ -1,6 +1,5 @@
 package cn.novalon.gym.manage.sys.config;
 import cn.novalon.gym.manage.sys.audit.OperationLogWebFilter;
 import cn.novalon.gym.manage.sys.security.JwtAuthenticationFilter;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -12,20 +11,22 @@ import org.springframework.security.config.web.server.SecurityWebFiltersOrder;
 import org.springframework.security.config.web.server.ServerHttpSecurity;
 import org.springframework.security.web.server.SecurityWebFilterChain;
 /**
 * 安全配置类
 * 
 * @author 张翔
 * @date 2026-03-13
 */
@Configuration
@EnableWebFluxSecurity
 public class SecurityConfig {
    private static final Logger logger = LoggerFactory.getLogger(SecurityConfig.class);
    private final JwtAuthenticationFilter jwtAuthenticationFilter;
    private final OperationLogWebFilter operationLogWebFilter;
    private final Environment environment;
-    public SecurityConfig(JwtAuthenticationFilter jwtAuthenticationFilter, 
+    public SecurityConfig(JwtAuthenticationFilter jwtAuthenticationFilter, Environment environment) {
                         OperationLogWebFilter operationLogWebFilter,
                         Environment environment) {
        this.jwtAuthenticationFilter = jwtAuthenticationFilter;
        this.operationLogWebFilter = operationLogWebFilter;
        this.environment = environment;
    }
@@ -45,7 +46,6 @@ public class SecurityConfig {
                .httpBasic(ServerHttpSecurity.HttpBasicSpec::disable)
                .formLogin(ServerHttpSecurity.FormLoginSpec::disable)
                .addFilterBefore(jwtAuthenticationFilter, SecurityWebFiltersOrder.AUTHENTICATION)
                .addFilterAfter(operationLogWebFilter, SecurityWebFiltersOrder.AUTHORIZATION)
                .authorizeExchange(spec -> {
                    spec.pathMatchers("/api/auth/**").permitAll()
                            .pathMatchers("/api/public/**").permitAll()
@@ -24,8 +24,6 @@ public interface ISysMenuRepository {
    Mono<SysMenu> save(SysMenu sysMenu);
    Mono<SysMenu> update(SysMenu sysMenu);
    Mono<Void> deleteById(Long id);
    Flux<SysMenu> findAll();
@@ -28,8 +28,6 @@ public interface ISysUserRepository {
    Mono<SysUser> save(SysUser sysUser);
    Mono<SysUser> update(SysUser sysUser);
    Mono<Void> deleteById(Long id);
    Flux<SysUser> findAll();
@@ -48,11 +48,13 @@ public class DictionaryService implements IDictionaryService {
    @Override
    public Mono<Dictionary> save(Dictionary dictionary) {
        if (dictionary.getId() == null) {
            dictionary.setCreatedAt(LocalDateTime.now());
            return checkTypeAndCodeExists(dictionary.getType(), dictionary.getCode())
                    .flatMap(exists -> {
                        if (exists) {
                            return Mono.error(new DictionaryAlreadyExistsException(dictionary.getType(), dictionary.getCode()));
                        }
                        dictionary.setUpdatedAt(LocalDateTime.now());
                        return repository.save(dictionary);
                    });
        }
@@ -29,6 +29,7 @@ public class OperationLogService implements IOperationLogService {
    @Override
    public Mono<OperationLog> save(OperationLog log) {
        log.setCreatedAt(LocalDateTime.now());
        return logRepository.save(log);
    }
@@ -1,7 +1,5 @@
 package cn.novalon.gym.manage.sys.core.service.impl;
 import cn.novalon.gym.manage.sys.audit.AuditLogHelper;
 import cn.novalon.gym.manage.sys.audit.service.IAuditLogService;
 import cn.novalon.gym.manage.sys.core.domain.SysConfig;
 import cn.novalon.gym.manage.sys.core.repository.ISysConfigRepository;
 import cn.novalon.gym.manage.sys.core.service.ISysConfigService;
@@ -9,15 +7,19 @@ import org.springframework.stereotype.Service;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 /**
 * 系统配置服务实现类
 * 
 * @author 张翔
 * @date 2026-03-14
 */
@Service
 public class SysConfigService implements ISysConfigService {
    private final ISysConfigRepository repository;
    private final IAuditLogService auditLogService;
-    public SysConfigService(ISysConfigRepository repository, IAuditLogService auditLogService) {
+    public SysConfigService(ISysConfigRepository repository) {
        this.repository = repository;
        this.auditLogService = auditLogService;
    }
    @Override
@@ -26,28 +28,27 @@ public class SysConfigService implements ISysConfigService {
    }
    @Override
    // @Cacheable(value = "sysConfig", key = "#id")
    public Mono<SysConfig> findById(Long id) {
        return repository.findById(id);
    }
    @Override
    // @Cacheable(value = "sysConfig", key = "#configKey")
    public Mono<SysConfig> findByConfigKey(String configKey) {
        return repository.findByConfigKeyAndDeletedAtIsNull(configKey);
    }
    @Override
    // @CacheEvict(value = "sysConfig", allEntries = true)
    public Mono<SysConfig> save(SysConfig config) {
-        return repository.save(config)
+        return repository.save(config);
                .flatMap(saved -> AuditLogHelper.record(auditLogService, "Config", saved.getId(), "CREATE", saved)
                        .thenReturn(saved));
    }
    @Override
    // @CacheEvict(value = "sysConfig", key = "#id")
    public Mono<Void> deleteById(Long id) {
-        return repository.findById(id)
+        return repository.deleteByIdAndDeletedAtIsNull(id);
                .flatMap(config -> repository.deleteByIdAndDeletedAtIsNull(id)
                        .then(AuditLogHelper.record(auditLogService, "Config", id, "DELETE", config, null)))
                .then();
    }
    @Override
@@ -1,7 +1,5 @@
 package cn.novalon.gym.manage.sys.core.service.impl;
 import cn.novalon.gym.manage.sys.audit.AuditLogHelper;
 import cn.novalon.gym.manage.sys.audit.service.IAuditLogService;
 import cn.novalon.gym.manage.sys.core.domain.SysDictType;
 import cn.novalon.gym.manage.sys.core.repository.ISysDictTypeRepository;
 import cn.novalon.gym.manage.sys.core.service.ISysDictTypeService;
@@ -9,15 +7,19 @@ import org.springframework.stereotype.Service;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 /**
 * 字典类型服务实现类
 * 
 * @author 张翔
 * @date 2026-03-14
 */
@Service
 public class SysDictTypeService implements ISysDictTypeService {
    private final ISysDictTypeRepository repository;
    private final IAuditLogService auditLogService;
-    public SysDictTypeService(ISysDictTypeRepository repository, IAuditLogService auditLogService) {
+    public SysDictTypeService(ISysDictTypeRepository repository) {
        this.repository = repository;
        this.auditLogService = auditLogService;
    }
    @Override
@@ -37,16 +39,11 @@ public class SysDictTypeService implements ISysDictTypeService {
    @Override
    public Mono<SysDictType> save(SysDictType dictType) {
-        return repository.save(dictType)
+        return repository.save(dictType);
                .flatMap(saved -> AuditLogHelper.record(auditLogService, "Dict", saved.getId(), "CREATE", saved)
                        .thenReturn(saved));
    }
    @Override
    public Mono<Void> deleteById(Long id) {
-        return repository.findById(id)
+        return repository.deleteByIdAndDeletedAtIsNull(id);
                .flatMap(dict -> repository.deleteByIdAndDeletedAtIsNull(id)
                        .then(AuditLogHelper.record(auditLogService, "Dict", id, "DELETE", dict, null)))
                .then();
    }
 }
@@ -6,8 +6,6 @@ import cn.novalon.gym.manage.sys.core.service.ISysMenuService;
 import cn.novalon.gym.manage.sys.core.command.CreateMenuCommand;
 import cn.novalon.gym.manage.sys.core.command.UpdateMenuCommand;
 import cn.novalon.gym.manage.common.util.StatusConstants;
 import cn.novalon.gym.manage.sys.audit.AuditLogHelper;
 import cn.novalon.gym.manage.sys.audit.service.IAuditLogService;
 import org.springframework.stereotype.Service;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
@@ -26,11 +24,9 @@ import java.util.stream.Collectors;
 public class SysMenuService implements ISysMenuService {
    private final ISysMenuRepository menuRepository;
    private final IAuditLogService auditLogService;
-    public SysMenuService(ISysMenuRepository menuRepository, IAuditLogService auditLogService) {
+    public SysMenuService(ISysMenuRepository menuRepository) {
        this.menuRepository = menuRepository;
        this.auditLogService = auditLogService;
    }
    @Override
@@ -50,9 +46,8 @@ public class SysMenuService implements ISysMenuService {
    @Override
    public Mono<SysMenu> createMenu(SysMenu menu) {
-        return menuRepository.save(menu)
+        menu.setCreatedAt(LocalDateTime.now());
-                .flatMap(saved -> AuditLogHelper.record(auditLogService, "Menu", saved.getId(), "CREATE", saved)
+        return menuRepository.save(menu);
                        .thenReturn(saved));
    }
    @Override
@@ -65,18 +60,14 @@ public class SysMenuService implements ISysMenuService {
        menu.setComponent(command.component());
        menu.setPerms(command.perms());
        menu.setStatus(command.status() != null ? command.status() : StatusConstants.ENABLED);
-        return menuRepository.save(menu)
+        menu.setCreatedAt(LocalDateTime.now());
-                .flatMap(saved -> AuditLogHelper.record(auditLogService, "Menu", saved.getId(), "CREATE", saved)
+        return menuRepository.save(menu);
                        .thenReturn(saved));
    }
    @Override
    public Mono<SysMenu> updateMenu(SysMenu menu) {
        menu.setUpdatedAt(LocalDateTime.now());
-        return menuRepository.findById(menu.getId())
+        return menuRepository.save(menu);
                .flatMap(before -> menuRepository.update(menu)
                        .flatMap(saved -> AuditLogHelper.record(auditLogService, "Menu", saved.getId(), "UPDATE", before, saved)
                                .thenReturn(saved)));
    }
    @Override
@@ -84,15 +75,6 @@ public class SysMenuService implements ISysMenuService {
        return menuRepository.findById(command.id())
                .switchIfEmpty(Mono.error(new RuntimeException("Menu not found")))
                .flatMap(menu -> {
                    SysMenu before = new SysMenu();
                    before.setId(menu.getId());
                    before.setParentId(menu.getParentId());
                    before.setMenuName(menu.getMenuName());
                    before.setMenuType(menu.getMenuType());
                    before.setOrderNum(menu.getOrderNum());
                    before.setComponent(menu.getComponent());
                    before.setPerms(menu.getPerms());
                    before.setStatus(menu.getStatus());
                    if (command.parentId() != null) {
                        menu.setParentId(command.parentId());
                    }
@@ -115,18 +97,13 @@ public class SysMenuService implements ISysMenuService {
                        menu.setStatus(command.status());
                    }
                    menu.setUpdatedAt(LocalDateTime.now());
-                    return menuRepository.update(menu)
+                    return menuRepository.save(menu);
                            .flatMap(saved -> AuditLogHelper.record(auditLogService, "Menu", saved.getId(), "UPDATE", before, saved)
                                    .thenReturn(saved));
                });
    }
    @Override
    public Mono<Void> deleteMenu(Long id) {
-        return menuRepository.findById(id)
+        return menuRepository.deleteById(id);
                .flatMap(menu -> menuRepository.deleteById(id)
                        .then(AuditLogHelper.record(auditLogService, "Menu", id, "DELETE", menu, null)))
                .then();
    }
    @Override
@@ -1,15 +1,11 @@
 package cn.novalon.gym.manage.sys.core.service.impl;
 import cn.novalon.gym.manage.common.util.StatusConstants;
 import cn.novalon.gym.manage.sys.audit.AuditLogHelper;
 import cn.novalon.gym.manage.sys.audit.service.IAuditLogService;
 import cn.novalon.gym.manage.sys.core.domain.SysPermission;
 import cn.novalon.gym.manage.sys.core.domain.SysRolePermission;
 import cn.novalon.gym.manage.sys.core.repository.ISysPermissionRepository;
 import cn.novalon.gym.manage.sys.core.repository.ISysRolePermissionRepository;
 import cn.novalon.gym.manage.sys.core.service.ISysPermissionService;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.data.domain.Sort;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -28,18 +24,13 @@ import java.util.List;
@Service
 public class SysPermissionService implements ISysPermissionService {
    private static final Logger logger = LoggerFactory.getLogger(SysPermissionService.class);
    private final ISysPermissionRepository permissionRepository;
    private final ISysRolePermissionRepository rolePermissionRepository;
    private final IAuditLogService auditLogService;
    public SysPermissionService(ISysPermissionRepository permissionRepository, 
-                                ISysRolePermissionRepository rolePermissionRepository,
+                                ISysRolePermissionRepository rolePermissionRepository) {
                                IAuditLogService auditLogService) {
        this.permissionRepository = permissionRepository;
        this.rolePermissionRepository = rolePermissionRepository;
        this.auditLogService = auditLogService;
    }
    @Override
@@ -69,41 +60,25 @@ public class SysPermissionService implements ISysPermissionService {
    @Override
    public Mono<SysPermission> createPermission(SysPermission permission) {
        permission.setCreatedAt(LocalDateTime.now());
        if (permission.getStatus() == null) {
            permission.setStatus(StatusConstants.ENABLED);
        }
-        return permissionRepository.save(permission)
+        return permissionRepository.save(permission);
                .flatMap(saved -> AuditLogHelper.record(auditLogService, "Permission", saved.getId(), "CREATE", saved)
                        .doOnError(e -> logger.error("Audit log failed for Permission CREATE id={}: {}", saved.getId(), e.getMessage()))
                        .thenReturn(saved));
    }
    @Override
    public Mono<SysPermission> updatePermission(SysPermission permission) {
        permission.setUpdatedAt(LocalDateTime.now());
-        return permissionRepository.findById(permission.getId())
+        return permissionRepository.updatePermission(permission);
                .flatMap(before -> permissionRepository.updatePermission(permission)
                        .flatMap(saved -> AuditLogHelper.record(auditLogService, "Permission", saved.getId(), "UPDATE", before, saved)
                                .thenReturn(saved)));
    }
    @Override
    public Mono<Void> deletePermission(Long id) {
        return permissionRepository.findById(id)
                .flatMap(permission -> {
                    SysPermission before = new SysPermission();
                    before.setId(permission.getId());
                    before.setPermissionName(permission.getPermissionName());
                    before.setPermissionCode(permission.getPermissionCode());
                    before.setResource(permission.getResource());
                    before.setAction(permission.getAction());
                    before.setStatus(permission.getStatus());
                    before.setCreatedAt(permission.getCreatedAt());
                    before.setUpdatedAt(permission.getUpdatedAt());
                    before.setDeletedAt(permission.getDeletedAt());
                    permission.delete();
                    return permissionRepository.updatePermission(permission)
                            .flatMap(saved -> AuditLogHelper.record(auditLogService, "Permission", id, "DELETE", before, saved))
                            .then(rolePermissionRepository.deleteByPermissionId(id));
                });
    }
@@ -124,7 +99,7 @@ public class SysPermissionService implements ISysPermissionService {
    }
    @Override
-    @Transactional(transactionManager = "connectionFactoryTransactionManager")
+    @Transactional
    public Mono<Void> assignPermissionsToRole(Long roleId, List<Long> permissionIds) {
        return rolePermissionRepository.deleteByRoleId(roleId)
                .then(Flux.fromIterable(permissionIds)
@@ -132,6 +107,7 @@ public class SysPermissionService implements ISysPermissionService {
                            SysRolePermission rolePermission = new SysRolePermission();
                            rolePermission.setRoleId(roleId);
                            rolePermission.setPermissionId(permissionId);
                            rolePermission.setCreatedAt(LocalDateTime.now());
                            return rolePermissionRepository.save(rolePermission);
                        })
                        .then());
@@ -1,8 +1,6 @@
 package cn.novalon.gym.manage.sys.core.service.impl;
 import cn.novalon.gym.manage.common.util.StatusConstants;
 import cn.novalon.gym.manage.sys.audit.AuditLogHelper;
 import cn.novalon.gym.manage.sys.audit.service.IAuditLogService;
 import cn.novalon.gym.manage.sys.core.domain.SysRole;
 import cn.novalon.gym.manage.sys.core.query.SysRoleQuery;
 import cn.novalon.gym.manage.sys.core.repository.ISysRoleRepository;
@@ -23,6 +21,12 @@ import reactor.core.publisher.Mono;
 import java.time.LocalDateTime;
 /**
 * 系统角色服务实现类
 * 
 * @author 张翔
 * @date 2026-03-14
 */
@Service
 public class SysRoleService implements ISysRoleService {
@@ -31,16 +35,13 @@ public class SysRoleService implements ISysRoleService {
    private final ISysUserService userService;
    private final IUserRoleRepository userRoleRepository;
    private final ISysRolePermissionRepository rolePermissionRepository;
    private final IAuditLogService auditLogService;
    public SysRoleService(ISysRoleRepository roleRepository, ISysUserService userService,
-                          IUserRoleRepository userRoleRepository, ISysRolePermissionRepository rolePermissionRepository,
+                          IUserRoleRepository userRoleRepository, ISysRolePermissionRepository rolePermissionRepository) {
                          IAuditLogService auditLogService) {
        this.roleRepository = roleRepository;
        this.userService = userService;
        this.userRoleRepository = userRoleRepository;
        this.rolePermissionRepository = rolePermissionRepository;
        this.auditLogService = auditLogService;
    }
    @Override
@@ -75,9 +76,7 @@ public class SysRoleService implements ISysRoleService {
        if (role.getStatus() == null) {
            role.setStatus(StatusConstants.ENABLED);
        }
-        return roleRepository.save(role)
+        return roleRepository.save(role);
                .flatMap(saved -> AuditLogHelper.record(auditLogService, "Role", saved.getId(), "CREATE", saved)
                        .thenReturn(saved));
    }
    @Override
@@ -89,18 +88,13 @@ public class SysRoleService implements ISysRoleService {
        role.setRoleSort(command.roleSort());
        role.setStatus(command.status() != null ? command.status() : StatusConstants.ENABLED);
        role.setCreatedAt(LocalDateTime.now());
-        return roleRepository.save(role)
+        return roleRepository.save(role);
                .flatMap(saved -> AuditLogHelper.record(auditLogService, "Role", saved.getId(), "CREATE", saved)
                        .thenReturn(saved));
    }
    @Override
    public Mono<SysRole> updateRole(SysRole role) {
        role.setUpdatedAt(LocalDateTime.now());
-        return roleRepository.findById(role.getId())
+        return roleRepository.save(role);
                .flatMap(before -> roleRepository.updateRole(role)
                        .flatMap(saved -> AuditLogHelper.record(auditLogService, "Role", saved.getId(), "UPDATE", before, saved)
                                .thenReturn(saved)));
    }
    @Override
@@ -108,15 +102,6 @@ public class SysRoleService implements ISysRoleService {
        return roleRepository.findById(command.id())
                .switchIfEmpty(Mono.error(new RuntimeException("Role not found")))
                .flatMap(role -> {
                    SysRole before = new SysRole();
                    before.setId(role.getId());
                    before.setRoleName(role.getRoleName());
                    before.setRoleKey(role.getRoleKey());
                    before.setRoleSort(role.getRoleSort());
                    before.setStatus(role.getStatus());
                    before.setCreatedAt(role.getCreatedAt());
                    before.setUpdatedAt(role.getUpdatedAt());
                    before.setDeletedAt(role.getDeletedAt());
                    if (command.roleName() != null) {
                        role.setRoleName(command.roleName());
                    }
@@ -130,14 +115,12 @@ public class SysRoleService implements ISysRoleService {
                        role.setStatus(command.status());
                    }
                    role.setUpdatedAt(LocalDateTime.now());
-                    return roleRepository.updateRole(role)
+                    return roleRepository.save(role);
                            .flatMap(saved -> AuditLogHelper.record(auditLogService, "Role", saved.getId(), "UPDATE", before, saved)
                                    .thenReturn(saved));
                });
    }
    @Override
-    @Transactional(transactionManager = "connectionFactoryTransactionManager")
+    @Transactional
    public Mono<Void> deleteRole(Long id) {
        logger.debug("开始删除角色，ID: {}", id);
@@ -155,8 +138,7 @@ public class SysRoleService implements ISysRoleService {
                            .doOnError(e -> logger.error("更新用户角色ID失败", e))
                            .then(roleRepository.deleteById(id))
                            .doOnSuccess(v -> logger.debug("成功删除角色"))
-                            .doOnError(e -> logger.error("删除角色失败", e))
+                            .doOnError(e -> logger.error("删除角色失败", e));
                            .then(AuditLogHelper.record(auditLogService, "Role", id, "DELETE", role, null));
                });
    }
@@ -174,19 +156,8 @@ public class SysRoleService implements ISysRoleService {
    public Mono<SysRole> logicalDeleteRole(Long id) {
        return roleRepository.findByIdIncludingDeleted(id)
                .flatMap(role -> {
                    SysRole before = new SysRole();
                    before.setId(role.getId());
                    before.setRoleName(role.getRoleName());
                    before.setRoleKey(role.getRoleKey());
                    before.setRoleSort(role.getRoleSort());
                    before.setStatus(role.getStatus());
                    before.setCreatedAt(role.getCreatedAt());
                    before.setUpdatedAt(role.getUpdatedAt());
                    before.setDeletedAt(role.getDeletedAt());
                    role.delete();
-                    return roleRepository.updateRole(role)
+                    return roleRepository.updateRole(role);
                            .flatMap(saved -> AuditLogHelper.record(auditLogService, "Role", saved.getId(), "DELETE", before, saved)
                                    .thenReturn(saved));
                });
    }
@@ -1,8 +1,6 @@
 package cn.novalon.gym.manage.sys.core.service.impl;
 import cn.novalon.gym.manage.common.util.StatusConstants;
 import cn.novalon.gym.manage.sys.audit.AuditLogHelper;
 import cn.novalon.gym.manage.sys.audit.service.IAuditLogService;
 import cn.novalon.gym.manage.sys.core.domain.SysUser;
 import cn.novalon.gym.manage.sys.core.domain.SysRole;
 import cn.novalon.gym.manage.sys.core.domain.UserRole;
@@ -28,6 +26,16 @@ import reactor.core.publisher.Mono;
 import java.time.LocalDateTime;
 import java.util.List;
 /**
 * 用户服务实现类
 * 
 * 文件定义：实现用户管理的核心业务逻辑
 * 涉及业务：用户注册、登录、信息修改、删除、密码修改、逻辑删除等用户生命周期管理
 * 算法：使用R2DBC进行响应式数据库操作，支持分页查询、条件查询、批量操作
 * 
 * @author 张翔
 * @date 2026-03-13
 */
@Service
 public class SysUserService implements ISysUserService {
@@ -36,18 +44,15 @@ public class SysUserService implements ISysUserService {
    private final ISysRoleRepository roleRepository;
    private final IUserRoleRepository userRoleRepository;
    private final PasswordEncoder passwordEncoder;
    private final IAuditLogService auditLogService;
    public SysUserService(ISysUserRepository userRepository,
            ISysRoleRepository roleRepository,
            IUserRoleRepository userRoleRepository,
-            @Qualifier("passwordEncoder") PasswordEncoder passwordEncoder,
+            @Qualifier("passwordEncoder") PasswordEncoder passwordEncoder) {
            IAuditLogService auditLogService) {
        this.userRepository = userRepository;
        this.roleRepository = roleRepository;
        this.userRoleRepository = userRoleRepository;
        this.passwordEncoder = passwordEncoder;
        this.auditLogService = auditLogService;
        logger.info("使用的密码编码器类型: {}", passwordEncoder.getClass().getName());
    }
@@ -108,9 +113,7 @@ public class SysUserService implements ISysUserService {
        if (user.getStatus() == null) {
            user.setStatus(StatusConstants.ENABLED);
        }
-        return userRepository.save(user)
+        return userRepository.save(user);
                .flatMap(saved -> AuditLogHelper.record(auditLogService, "User", saved.getId(), "CREATE", saved)
                        .thenReturn(saved));
    }
    @Override
@@ -124,18 +127,13 @@ public class SysUserService implements ISysUserService {
        user.setPhone(command.phone());
        user.setRoleId(command.roleId());
        user.setStatus(command.status() != null ? command.status() : StatusConstants.ENABLED);
-        return userRepository.save(user)
+        return userRepository.save(user);
                .flatMap(saved -> AuditLogHelper.record(auditLogService, "User", saved.getId(), "CREATE", saved)
                        .thenReturn(saved));
    }
    @Override
    public Mono<SysUser> updateUser(SysUser user) {
        user.setUpdatedAt(LocalDateTime.now());
-        return userRepository.findById(user.getId())
+        return userRepository.save(user);
                .flatMap(before -> userRepository.update(user)
                        .flatMap(saved -> AuditLogHelper.record(auditLogService, "User", saved.getId(), "UPDATE", before, saved)
                                .thenReturn(saved)));
    }
    @Override
@@ -143,17 +141,6 @@ public class SysUserService implements ISysUserService {
        return userRepository.findById(command.id())
                .switchIfEmpty(Mono.error(new RuntimeException("User not found")))
                .flatMap(user -> {
                    SysUser before = new SysUser();
                    before.setId(user.getId());
                    before.setUsername(user.getUsername());
                    before.setEmail(user.getEmail());
                    before.setNickname(user.getNickname());
                    before.setPhone(user.getPhone());
                    before.setRoleId(user.getRoleId());
                    before.setStatus(user.getStatus());
                    before.setCreatedAt(user.getCreatedAt());
                    before.setUpdatedAt(user.getUpdatedAt());
                    before.setDeletedAt(user.getDeletedAt());
                    if (command.username() != null) {
                        user.setUsername(command.username());
                    }
@@ -172,15 +159,12 @@ public class SysUserService implements ISysUserService {
                        user.setStatus(command.status());
                    }
                    user.setUpdatedAt(LocalDateTime.now());
-                    return userRepository.update(user)
+                    return userRepository.save(user);
                            .flatMap(saved -> AuditLogHelper
                                    .record(auditLogService, "User", saved.getId(), "UPDATE", before, saved)
                                    .thenReturn(saved));
                });
    }
    @Override
-    @Transactional(transactionManager = "connectionFactoryTransactionManager")
+    @Transactional
    public Mono<Void> deleteUser(Long id) {
        logger.debug("开始删除用户，ID: {}", id);
@@ -193,8 +177,7 @@ public class SysUserService implements ISysUserService {
                            .doOnError(e -> logger.error("删除用户角色关联记录失败", e))
                            .then(userRepository.deleteById(id))
                            .doOnSuccess(v -> logger.debug("成功删除用户"))
-                            .doOnError(e -> logger.error("删除用户失败", e))
+                            .doOnError(e -> logger.error("删除用户失败", e));
                            .then(AuditLogHelper.record(auditLogService, "User", id, "DELETE", user, null));
                });
    }
@@ -212,10 +195,7 @@ public class SysUserService implements ISysUserService {
                    }
                    user.setPassword(passwordEncoder.encode(newPassword));
                    user.setUpdatedAt(LocalDateTime.now());
-                    return userRepository.update(user)
+                    return userRepository.save(user);
                            .flatMap(saved -> AuditLogHelper
                                    .record(auditLogService, "User", saved.getId(), "UPDATE", saved)
                                    .thenReturn(saved));
                });
    }
@@ -237,20 +217,8 @@ public class SysUserService implements ISysUserService {
    public Mono<Void> logicalDeleteUser(Long id) {
        return userRepository.findByIdIncludingDeleted(id)
                .flatMap(user -> {
                    SysUser before = new SysUser();
                    before.setId(user.getId());
                    before.setUsername(user.getUsername());
                    before.setEmail(user.getEmail());
                    before.setNickname(user.getNickname());
                    before.setPhone(user.getPhone());
                    before.setRoleId(user.getRoleId());
                    before.setStatus(user.getStatus());
                    before.setCreatedAt(user.getCreatedAt());
                    before.setUpdatedAt(user.getUpdatedAt());
                    before.setDeletedAt(user.getDeletedAt());
                    user.setDeletedAt(LocalDateTime.now());
-                    return userRepository.save(user)
+                    return userRepository.save(user);
                            .flatMap(saved -> AuditLogHelper.record(auditLogService, "User", saved.getId(), "DELETE", before, saved));
                })
                .then();
    }
@@ -276,7 +244,7 @@ public class SysUserService implements ISysUserService {
    }
    @Override
-    @Transactional(transactionManager = "connectionFactoryTransactionManager")
+    @Transactional
    public Mono<Void> assignRolesToUser(Long userId, List<Long> roleIds) {
        logger.debug("开始为用户分配角色，用户ID: {}, 角色IDs: {}", userId, roleIds);
@@ -284,8 +252,7 @@ public class SysUserService implements ISysUserService {
            logger.debug("角色列表为空，删除用户的所有角色关联");
            return userRoleRepository.deleteByUserId(userId)
                    .doOnSuccess(v -> logger.debug("成功删除用户的所有角色关联"))
-                    .doOnError(e -> logger.error("删除用户角色关联失败", e))
+                    .doOnError(e -> logger.error("删除用户角色关联失败", e));
                    .then(AuditLogHelper.record(auditLogService, "User", userId, "UPDATE", null));
        }
        return userRoleRepository.deleteByUserId(userId)
@@ -298,12 +265,12 @@ public class SysUserService implements ISysUserService {
                                    UserRole userRole = new UserRole();
                                    userRole.setUserId(userId);
                                    userRole.setRoleId(roleId);
                                    userRole.setCreatedAt(LocalDateTime.now());
                                    return userRoleRepository.save(userRole)
                                            .doOnSuccess(v -> logger.debug("成功保存用户角色关联"))
                                            .doOnError(e -> logger.error("保存用户角色关联失败", e));
                                })
-                                .then())
+                                .then());
                .then(AuditLogHelper.record(auditLogService, "User", userId, "UPDATE", null));
    }
    @Override
@@ -1,13 +1,12 @@
 package cn.novalon.gym.manage.sys.util;
 import org.springframework.http.server.reactive.ServerHttpRequest;
 import org.springframework.web.reactive.function.server.ServerRequest;
 import java.net.InetSocketAddress;
 import java.util.Optional;
 /**
 * IP地址工具类
- * 用于从ServerRequest或ServerHttpRequest中获取客户端真实IP地址
+ * 用于从ServerRequest中获取客户端真实IP地址
 * 支持代理服务器场景(X-Forwarded-For, X-Real-IP)
 * 
 * @author 张翔
@@ -49,36 +48,6 @@ public class IpUtils {
        return UNKNOWN;
    }
    /**
     * 从ServerHttpRequest中获取客户端真实IP地址
     * 支持代理服务器场景,优先级: X-Forwarded-For > X-Real-IP > RemoteAddress
     * 
     * @param request ServerHttpRequest对象
     * @return 客户端IP地址,获取失败返回"unknown"
     */
    public static String getClientIp(ServerHttpRequest request) {
        if (request == null) {
            return UNKNOWN;
        }
        String ip = getXForwardedForIp(request);
        if (isValidIp(ip)) {
            return ip;
        }
        ip = getXRealIp(request);
        if (isValidIp(ip)) {
            return ip;
        }
        ip = getRemoteAddress(request);
        if (isValidIp(ip)) {
            return ip;
        }
        return UNKNOWN;
    }
    /**
     * 从X-Forwarded-For头获取IP地址
     * X-Forwarded-For格式: client, proxy1, proxy2
@@ -129,48 +98,4 @@ public class IpUtils {
    private static boolean isValidIp(String ip) {
        return ip != null && ip.length() > 0 && !UNKNOWN.equalsIgnoreCase(ip);
    }
    /**
     * 从X-Forwarded-For头获取IP地址(ServerHttpRequest版本)
     * X-Forwarded-For格式: client, proxy1, proxy2
     * 取第一个非unknown的有效IP
     */
    private static String getXForwardedForIp(ServerHttpRequest request) {
        String ip = request.getHeaders().getFirst("X-Forwarded-For");
        if (ip != null && ip.length() > 0 && !UNKNOWN.equalsIgnoreCase(ip)) {
            int index = ip.indexOf(",");
            if (index != -1) {
                return ip.substring(0, index);
            }
            return ip;
        }
        return null;
    }
    /**
     * 从X-Real-IP头获取IP地址(ServerHttpRequest版本)
     */
    private static String getXRealIp(ServerHttpRequest request) {
        String ip = request.getHeaders().getFirst("X-Real-IP");
        if (ip != null && ip.length() > 0 && !UNKNOWN.equalsIgnoreCase(ip)) {
            return ip;
        }
        return null;
    }
    /**
     * 从RemoteAddress获取IP地址(ServerHttpRequest版本)
     * 将IPv6本地地址转换为IPv4格式
     */
    private static String getRemoteAddress(ServerHttpRequest request) {
        InetSocketAddress remoteAddress = request.getRemoteAddress();
        if (remoteAddress != null) {
            String ip = remoteAddress.getAddress().getHostAddress();
            if (LOCALHOST_IPV6.equals(ip)) {
                ip = LOCALHOST_IP;
            }
            return ip;
        }
        return null;
    }
 }
@@ -1,6 +1,5 @@
 package cn.novalon.gym.manage.sys.config;
 import cn.novalon.gym.manage.sys.audit.OperationLogWebFilter;
 import cn.novalon.gym.manage.sys.security.JwtAuthenticationFilter;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -17,9 +16,6 @@ class SecurityConfigTest {
    @Mock
    private JwtAuthenticationFilter jwtAuthenticationFilter;
    @Mock
    private OperationLogWebFilter operationLogWebFilter;
    @Mock
    private Environment environment;
@@ -27,7 +23,7 @@ class SecurityConfigTest {
    @BeforeEach
    void setUp() {
-        securityConfig = new SecurityConfig(jwtAuthenticationFilter, operationLogWebFilter, environment);
+        securityConfig = new SecurityConfig(jwtAuthenticationFilter, environment);
    }
    @Test
@@ -43,7 +43,6 @@ class OperationLogServiceTest {
        testLog.setDuration(100L);
        testLog.setIp("192.168.1.1");
        testLog.setStatus("1");
        testLog.setCreatedAt(LocalDateTime.now());
    }
    @Test
@@ -1,6 +1,5 @@
 package cn.novalon.gym.manage.sys.core.service.impl;
 import cn.novalon.gym.manage.sys.audit.service.IAuditLogService;
 import cn.novalon.gym.manage.sys.core.domain.SysConfig;
 import cn.novalon.gym.manage.sys.core.repository.ISysConfigRepository;
 import org.junit.jupiter.api.BeforeEach;
@@ -27,16 +26,13 @@ class SysConfigServiceTest {
    @Mock
    private ISysConfigRepository repository;
    @Mock
    private IAuditLogService auditLogService;
    private SysConfigService configService;
    private SysConfig testConfig;
    @BeforeEach
    void setUp() {
-        configService = new SysConfigService(repository, auditLogService);
+        configService = new SysConfigService(repository);
        testConfig = new SysConfig();
        testConfig.setId(1L);
@@ -114,13 +110,11 @@ class SysConfigServiceTest {
    @Test
    void testDeleteById() {
        when(repository.findById(1L)).thenReturn(Mono.just(testConfig));
        when(repository.deleteByIdAndDeletedAtIsNull(1L)).thenReturn(Mono.empty());
        StepVerifier.create(configService.deleteById(1L))
                .verifyComplete();
        verify(repository).findById(1L);
        verify(repository).deleteByIdAndDeletedAtIsNull(1L);
    }
@@ -1,6 +1,5 @@
 package cn.novalon.gym.manage.sys.core.service.impl;
 import cn.novalon.gym.manage.sys.audit.service.IAuditLogService;
 import cn.novalon.gym.manage.sys.core.domain.SysDictType;
 import cn.novalon.gym.manage.sys.core.repository.ISysDictTypeRepository;
 import org.junit.jupiter.api.BeforeEach;
@@ -24,15 +23,12 @@ class SysDictTypeServiceTest {
    @Mock
    private ISysDictTypeRepository repository;
    @Mock
    private IAuditLogService auditLogService;
    private SysDictTypeService dictTypeService;
    private SysDictType testDictType;
    @BeforeEach
    void setUp() {
-        dictTypeService = new SysDictTypeService(repository, auditLogService);
+        dictTypeService = new SysDictTypeService(repository);
        testDictType = new SysDictType();
        testDictType.setId(1L);
@@ -97,7 +93,6 @@ class SysDictTypeServiceTest {
    @Test
    void testDeleteById() {
        when(repository.findById(1L)).thenReturn(Mono.just(testDictType));
        when(repository.deleteByIdAndDeletedAtIsNull(1L)).thenReturn(Mono.empty());
        Mono<Void> result = dictTypeService.deleteById(1L);
@@ -105,7 +100,6 @@ class SysDictTypeServiceTest {
        StepVerifier.create(result)
                .verifyComplete();
        verify(repository).findById(1L);
        verify(repository).deleteByIdAndDeletedAtIsNull(1L);
    }
 }
@@ -4,7 +4,6 @@ import cn.novalon.gym.manage.sys.core.domain.SysMenu;
 import cn.novalon.gym.manage.sys.core.repository.ISysMenuRepository;
 import cn.novalon.gym.manage.sys.core.command.CreateMenuCommand;
 import cn.novalon.gym.manage.sys.core.command.UpdateMenuCommand;
 import cn.novalon.gym.manage.sys.audit.service.IAuditLogService;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -26,15 +25,12 @@ class SysMenuServiceTest {
    @Mock
    private ISysMenuRepository menuRepository;
    @Mock
    private IAuditLogService auditLogService;
    private SysMenuService menuService;
    private SysMenu testMenu;
    @BeforeEach
    void setUp() {
-        menuService = new SysMenuService(menuRepository, auditLogService);
+        menuService = new SysMenuService(menuRepository);
        testMenu = new SysMenu();
        testMenu.setId(1L);
@@ -133,8 +129,7 @@ class SysMenuServiceTest {
    @Test
    void testUpdateMenu() {
-        when(menuRepository.findById(1L)).thenReturn(Mono.just(testMenu));
+        when(menuRepository.save(any(SysMenu.class))).thenReturn(Mono.just(testMenu));
        when(menuRepository.update(any(SysMenu.class))).thenReturn(Mono.just(testMenu));
        Mono<SysMenu> result = menuService.updateMenu(testMenu);
@@ -143,8 +138,7 @@ class SysMenuServiceTest {
                        menu.getUpdatedAt() != null)
                .verifyComplete();
-        verify(menuRepository).findById(1L);
+        verify(menuRepository).save(any(SysMenu.class));
        verify(menuRepository).update(any(SysMenu.class));
    }
    @Test
@@ -153,7 +147,7 @@ class SysMenuServiceTest {
                1L, 0L, "系统管理（更新）", "M", 1, "system", "system:manage", 1);
        when(menuRepository.findById(1L)).thenReturn(Mono.just(testMenu));
-        when(menuRepository.update(any(SysMenu.class))).thenReturn(Mono.just(testMenu));
+        when(menuRepository.save(any(SysMenu.class))).thenReturn(Mono.just(testMenu));
        Mono<SysMenu> result = menuService.updateMenu(command);
@@ -163,7 +157,7 @@ class SysMenuServiceTest {
                .verifyComplete();
        verify(menuRepository).findById(1L);
-        verify(menuRepository).update(any(SysMenu.class));
+        verify(menuRepository).save(any(SysMenu.class));
    }
    @Test
@@ -206,7 +200,7 @@ class SysMenuServiceTest {
        updatedMenu.setUpdatedAt(LocalDateTime.now());
        when(menuRepository.findById(1L)).thenReturn(Mono.just(existingMenu));
-        when(menuRepository.update(any(SysMenu.class))).thenReturn(Mono.just(updatedMenu));
+        when(menuRepository.save(any(SysMenu.class))).thenReturn(Mono.just(updatedMenu));
        UpdateMenuCommand command = new UpdateMenuCommand(
                1L, null, null, null, null, null, null, null);
@@ -216,7 +210,7 @@ class SysMenuServiceTest {
                .verifyComplete();
        verify(menuRepository).findById(1L);
-        verify(menuRepository).update(any(SysMenu.class));
+        verify(menuRepository).save(any(SysMenu.class));
    }
    @Test
@@ -243,7 +237,7 @@ class SysMenuServiceTest {
        updatedMenu.setUpdatedAt(LocalDateTime.now());
        when(menuRepository.findById(1L)).thenReturn(Mono.just(existingMenu));
-        when(menuRepository.update(any(SysMenu.class))).thenReturn(Mono.just(updatedMenu));
+        when(menuRepository.save(any(SysMenu.class))).thenReturn(Mono.just(updatedMenu));
        UpdateMenuCommand command = new UpdateMenuCommand(
                1L, 2L, "系统管理（更新）", "C", 2, "system_updated", "system:manage_updated", 0);
@@ -253,12 +247,11 @@ class SysMenuServiceTest {
                .verifyComplete();
        verify(menuRepository).findById(1L);
-        verify(menuRepository).update(any(SysMenu.class));
+        verify(menuRepository).save(any(SysMenu.class));
    }
    @Test
    void testDeleteMenu() {
        when(menuRepository.findById(1L)).thenReturn(Mono.just(testMenu));
        when(menuRepository.deleteById(1L)).thenReturn(Mono.empty());
        Mono<Void> result = menuService.deleteMenu(1L);
@@ -266,7 +259,6 @@ class SysMenuServiceTest {
        StepVerifier.create(result)
                .verifyComplete();
        verify(menuRepository).findById(1L);
        verify(menuRepository).deleteById(1L);
    }
@@ -1,6 +1,5 @@
 package cn.novalon.gym.manage.sys.core.service.impl;
 import cn.novalon.gym.manage.sys.audit.service.IAuditLogService;
 import cn.novalon.gym.manage.common.util.StatusConstants;
 import cn.novalon.gym.manage.sys.core.domain.SysRole;
 import cn.novalon.gym.manage.sys.core.query.SysRoleQuery;
@@ -47,16 +46,13 @@ class SysRoleServiceTest {
    @Mock
    private ISysRolePermissionRepository rolePermissionRepository;
    @Mock
    private IAuditLogService auditLogService;
    private SysRoleService roleService;
    private SysRole testRole;
    @BeforeEach
    void setUp() {
-        roleService = new SysRoleService(roleRepository, userService, userRoleRepository, rolePermissionRepository, auditLogService);
+        roleService = new SysRoleService(roleRepository, userService, userRoleRepository, rolePermissionRepository);
        testRole = new SysRole();
        testRole.setId(1L);
@@ -210,7 +206,7 @@ class SysRoleServiceTest {
        existingRole.setStatus(StatusConstants.ENABLED);
        when(roleRepository.findById(1L)).thenReturn(Mono.just(existingRole));
-        when(roleRepository.updateRole(any(SysRole.class))).thenReturn(Mono.just(testRole));
+        when(roleRepository.save(any(SysRole.class))).thenReturn(Mono.just(testRole));
        cn.novalon.gym.manage.sys.core.command.UpdateRoleCommand command = 
            new cn.novalon.gym.manage.sys.core.command.UpdateRoleCommand(
@@ -222,7 +218,7 @@ class SysRoleServiceTest {
                .verifyComplete();
        verify(roleRepository).findById(1L);
-        verify(roleRepository).updateRole(any(SysRole.class));
+        verify(roleRepository).save(any(SysRole.class));
    }
    @Test
@@ -235,7 +231,7 @@ class SysRoleServiceTest {
        existingRole.setStatus(StatusConstants.ENABLED);
        when(roleRepository.findById(1L)).thenReturn(Mono.just(existingRole));
-        when(roleRepository.updateRole(any(SysRole.class))).thenReturn(Mono.just(testRole));
+        when(roleRepository.save(any(SysRole.class))).thenReturn(Mono.just(testRole));
        cn.novalon.gym.manage.sys.core.command.UpdateRoleCommand command = 
            new cn.novalon.gym.manage.sys.core.command.UpdateRoleCommand(
@@ -247,7 +243,7 @@ class SysRoleServiceTest {
                .verifyComplete();
        verify(roleRepository).findById(1L);
-        verify(roleRepository).updateRole(any(SysRole.class));
+        verify(roleRepository).save(any(SysRole.class));
    }
    @Test
@@ -256,15 +252,13 @@ class SysRoleServiceTest {
        updateRole.setId(1L);
        updateRole.setRoleName("updated_admin");
-        when(roleRepository.findById(1L)).thenReturn(Mono.just(testRole));
+        when(roleRepository.save(any(SysRole.class))).thenReturn(Mono.just(testRole));
        when(roleRepository.updateRole(any(SysRole.class))).thenReturn(Mono.just(testRole));
        StepVerifier.create(roleService.updateRole(updateRole))
                .expectNextMatches(role -> role.getUpdatedAt() != null)
                .verifyComplete();
-        verify(roleRepository).findById(1L);
+        verify(roleRepository).save(any(SysRole.class));
        verify(roleRepository).updateRole(any(SysRole.class));
    }
    @Test
@@ -1,7 +1,6 @@
 package cn.novalon.gym.manage.sys.core.service.impl;
 import cn.novalon.gym.manage.common.util.StatusConstants;
 import cn.novalon.gym.manage.sys.audit.service.IAuditLogService;
 import cn.novalon.gym.manage.sys.config.IntegrationTestConfig;
 import cn.novalon.gym.manage.sys.core.domain.SysUser;
 import cn.novalon.gym.manage.sys.core.domain.SysRole;
@@ -77,9 +76,6 @@ class SysUserServiceIntegrationTest {
    @Autowired
    private IUserRoleRepository userRoleRepository;
    @Autowired
    private IAuditLogService auditLogService;
    @Autowired
    private R2dbcEntityTemplate r2dbcEntityTemplate;
@@ -89,7 +85,7 @@ class SysUserServiceIntegrationTest {
    @BeforeEach
    void setUp() {
        passwordEncoder = new BCryptPasswordEncoder(12);
-        userService = new SysUserService(userRepository, roleRepository, userRoleRepository, passwordEncoder, auditLogService);
+        userService = new SysUserService(userRepository, roleRepository, userRoleRepository, passwordEncoder);
        r2dbcEntityTemplate.delete(SysUser.class).all().block();
        r2dbcEntityTemplate.delete(SysRole.class).all().block();
@@ -1,8 +1,6 @@
 package cn.novalon.gym.manage.sys.core.service.impl;
 import cn.novalon.gym.manage.common.util.StatusConstants;
 import cn.novalon.gym.manage.sys.audit.service.IAuditLogService;
 import cn.novalon.gym.manage.sys.audit.domain.AuditLog;
 import cn.novalon.gym.manage.sys.core.domain.SysUser;
 import cn.novalon.gym.manage.sys.core.domain.UserRole;
 import cn.novalon.gym.manage.sys.core.repository.ISysUserRepository;
@@ -47,14 +45,11 @@ class SysUserServiceTest {
    @Mock
    private PasswordEncoder passwordEncoder;
    @Mock
    private IAuditLogService auditLogService;
    private SysUserService userService;
    @BeforeEach
    void setUp() {
-        userService = new SysUserService(userRepository, roleRepository, userRoleRepository, passwordEncoder, auditLogService);
+        userService = new SysUserService(userRepository, roleRepository, userRoleRepository, passwordEncoder);
    }
    @Test
@@ -169,8 +164,7 @@ class SysUserServiceTest {
        user.setUsername("testuser");
        user.setEmail("updated@example.com");
-        when(userRepository.findById(1L)).thenReturn(Mono.just(user));
+        when(userRepository.save(any(SysUser.class))).thenReturn(Mono.just(user));
        when(userRepository.update(any(SysUser.class))).thenReturn(Mono.just(user));
        StepVerifier.create(userService.updateUser(user))
                .expectNextMatches(updatedUser -> 
@@ -179,8 +173,7 @@ class SysUserServiceTest {
                )
                .verifyComplete();
-        verify(userRepository, times(1)).findById(1L);
+        verify(userRepository, times(1)).save(any(SysUser.class));
        verify(userRepository, times(1)).update(any(SysUser.class));
    }
    @Test
@@ -225,7 +218,7 @@ class SysUserServiceTest {
        when(userRepository.findById(1L)).thenReturn(Mono.just(user));
        when(passwordEncoder.matches("oldPassword", "$2b$12$oldPassword")).thenReturn(true);
        when(passwordEncoder.encode("newPassword")).thenReturn("$2b$12$newPassword");
-        when(userRepository.update(any(SysUser.class))).thenAnswer(invocation -> Mono.just(invocation.getArgument(0)));
+        when(userRepository.save(any(SysUser.class))).thenAnswer(invocation -> Mono.just(invocation.getArgument(0)));
        StepVerifier.create(userService.changePassword(1L, "oldPassword", "newPassword"))
                .expectNextMatches(updatedUser -> 
@@ -235,7 +228,7 @@ class SysUserServiceTest {
        verify(passwordEncoder, times(1)).matches("oldPassword", "$2b$12$oldPassword");
        verify(passwordEncoder, times(1)).encode("newPassword");
-        verify(userRepository, times(1)).update(any(SysUser.class));
+        verify(userRepository, times(1)).save(any(SysUser.class));
    }
    @Test
@@ -10,7 +10,6 @@ import cn.novalon.gym.manage.sys.core.service.ISysMenuService;
 import cn.novalon.gym.manage.sys.core.service.ISysRoleService;
 import cn.novalon.gym.manage.sys.core.service.ISysUserService;
 import cn.novalon.gym.manage.sys.core.service.impl.SysMenuService;
 import cn.novalon.gym.manage.sys.audit.service.IAuditLogService;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
@@ -62,9 +61,6 @@ class SystemConfigRegressionTest {
    @Mock
    private ISysMenuRepository menuRepository;
    @Mock
    private IAuditLogService auditLogService;
    private SysUser adminUser;
    private SysUser normalUser;
    private SysUser guestUser;
@@ -378,7 +374,7 @@ class SystemConfigRegressionTest {
    void testAdminUser_MenuManagement() {
        /* unused */
-        ISysMenuService menuService = new SysMenuService(menuRepository, auditLogService);
+        ISysMenuService menuService = new SysMenuService(menuRepository);
        StepVerifier.create(menuService.findAll())
                .expectNextCount(0)
@@ -388,7 +384,7 @@ class SystemConfigRegressionTest {
    @Test
    @DisplayName("3.2 普通用户 - 菜单访问控制")
    void testNormalUser_MenuAccess() {
-        ISysMenuService menuService = new SysMenuService(menuRepository, auditLogService);
+        ISysMenuService menuService = new SysMenuService(menuRepository);
        StepVerifier.create(menuService.findAll())
                .expectNextCount(0)
@@ -398,7 +394,7 @@ class SystemConfigRegressionTest {
    @Test
    @DisplayName("3.3 访客用户 - 菜单访问控制")
    void testGuestUser_MenuAccess() {
-        ISysMenuService menuService = new SysMenuService(menuRepository, auditLogService);
+        ISysMenuService menuService = new SysMenuService(menuRepository);
        StepVerifier.create(menuService.findAll())
                .expectNextCount(0)
@@ -408,7 +404,7 @@ class SystemConfigRegressionTest {
    @Test
    @DisplayName("3.4 菜单树构建 - 管理员视图")
    void testMenuTree_Build_Admin() {
-        ISysMenuService menuService = new SysMenuService(menuRepository, auditLogService);
+        ISysMenuService menuService = new SysMenuService(menuRepository);
        StepVerifier.create(menuService.findAll())
                .verifyComplete();
@@ -417,7 +413,7 @@ class SystemConfigRegressionTest {
    @Test
    @DisplayName("3.5 权限菜单过滤 - 普通用户视图")
    void testMenuFilter_NormalUser() {
-        ISysMenuService menuService = new SysMenuService(menuRepository, auditLogService);
+        ISysMenuService menuService = new SysMenuService(menuRepository);
        StepVerifier.create(menuService.findAll())
                .expectNextCount(0)
@@ -427,7 +423,7 @@ class SystemConfigRegressionTest {
    @Test
    @DisplayName("3.6 权限菜单过滤 - 访客视图")
    void testMenuFilter_Guest() {
-        ISysMenuService menuService = new SysMenuService(menuRepository, auditLogService);
+        ISysMenuService menuService = new SysMenuService(menuRepository);
        StepVerifier.create(menuService.findAll())
                .expectNextCount(0)
@@ -476,7 +472,7 @@ class SystemConfigRegressionTest {
    @Test
    @DisplayName("5.2 大量菜单加载性能测试")
    void testLargeMenuLoadPerformance() {
-        ISysMenuService menuService = new SysMenuService(menuRepository, auditLogService);
+        ISysMenuService menuService = new SysMenuService(menuRepository);
        long startTime = System.currentTimeMillis();
@@ -520,7 +516,7 @@ class SystemConfigRegressionTest {
    @Test
    @DisplayName("6.3 菜单层级结构完整性")
    void testMenuHierarchy_Integrity() {
-        ISysMenuService menuService = new SysMenuService(menuRepository, auditLogService);
+        ISysMenuService menuService = new SysMenuService(menuRepository);
        StepVerifier.create(menuService.findAll())
                .verifyComplete();
@@ -22,7 +22,7 @@ class IpUtilsTest {
    @Test
    @DisplayName("当request为null时,应返回unknown")
    void getClientIp_whenRequestIsNull_shouldReturnUnknown() {
-        String ip = IpUtils.getClientIp((ServerRequest) null);
+        String ip = IpUtils.getClientIp(null);
        assertEquals("unknown", ip);
    }
@@ -1,60 +0,0 @@
 # E2E测试说明
 ## 测试结构
 本项目的E2E测试采用分层测试策略：
 ### 冒烟测试（smoke/）
 快速验证基础功能是否正常工作。
 - `login-logout.spec.ts` - 登录登出基础流程
 ### 核心旅程测试（journeys/）
 验证关键业务端到端流程。
 - `admin-complete-workflow.spec.ts` - 管理员完整工作流
 - `user-permission-boundary.spec.ts` - 用户权限边界验证
 - `file-management-workflow.spec.ts` - 文件上传下载流程
 - `audit-workflow.spec.ts` - 审计日志查看流程
 ## 运行测试
 ### 运行冒烟测试
 ```bash
 npm run test:e2e:smoke
 ```
 ### 运行核心旅程测试
 ```bash
 npm run test:e2e:journeys
 ```
 ### 运行所有测试
 ```bash
 npm run test:e2e
 ```
 ## 测试数据
 测试使用的用户账号：
 - 管理员：username: `admin`, password: `Test@123`
 - 普通用户：username: `user`, password: `Test@123`
 ## 测试策略
 - **冒烟测试**：每次代码提交时运行，快速反馈
 - **核心旅程测试**：PR合并前运行，验证关键业务流程
 - **单元测试**：补充功能覆盖率，目标80%
 ## 维护指南
 1. 新增核心业务功能时，在 `journeys/` 目录下添加测试
 2. 新增基础功能时，在 `smoke/` 目录下添加测试
 3. 保持测试文件数量精简，避免重复测试
 4. 优先使用单元测试覆盖功能细节
@@ -1,65 +0,0 @@
 import { test, expect } from '@playwright/test';
 test.describe('API连通性测试', () => {
  test('验证网关服务健康状态', async ({ page }) => {
    await test.step('检查网关健康状态', async () => {
      const response = await page.request.get('http://localhost:8080/actuator/health');
      expect(response.status()).toBe(200);
      const data = await response.json();
      expect(data.status).toBe('UP');
    });
    await test.step('检查应用服务路由', async () => {
      const response = await page.request.get('http://localhost:8080/api/auth/health');
      expect(response.status()).toBe(200);
    });
  });
  test('验证前端与后端连通性', async ({ page }) => {
    await test.step('加载前端应用', async () => {
      await page.goto('/');
      await page.waitForLoadState('networkidle');
      // 验证页面标题
      const title = await page.title();
      expect(title).toContain('Novalon');
    });
    await test.step('检查API请求', async () => {
      // 监听网络请求
      const apiRequests = [];
      page.on('request', request => {
        if (request.url().includes('/api/')) {
          apiRequests.push({
            url: request.url(),
            method: request.method()
          });
        }
      });
      // 触发一些前端操作来生成API请求
      await page.goto('/login');
      await page.waitForLoadState('networkidle');
      // 验证是否有API请求发出
      expect(apiRequests.length).toBeGreaterThan(0);
    });
  });
  test('验证数据库连接状态', async ({ page }) => {
    await test.step('检查数据库健康状态', async () => {
      // 通过应用服务检查数据库连接
      const response = await page.request.get('http://localhost:8084/actuator/health');
      expect(response.status()).toBe(200);
      const data = await response.json();
      expect(data.status).toBe('UP');
      // 检查数据库组件状态
      if (data.components && data.components.db) {
        expect(data.components.db.status).toBe('UP');
      }
    });
  });
 });
@@ -1,197 +0,0 @@
 import { test, expect } from '@playwright/test';
 test.describe('认证和授权测试', () => {
  let authToken: string;
  let userId: number;
  test('用户登录测试', async ({ page }) => {
    await test.step('准备登录数据', async () => {
      console.log('准备登录测试数据...');
    });
    await test.step('发送登录请求', async () => {
      const response = await page.request.post('http://localhost:8080/api/auth/login', {
        headers: {
          'Content-Type': 'application/json'
        },
        data: {
          username: 'admin',
          password: 'admin123'
        }
      });
      expect(response.status()).toBe(200);
      const data = await response.json();
      expect(data).toHaveProperty('token');
      expect(data).toHaveProperty('userId');
      expect(data).toHaveProperty('username');
      authToken = data.token;
      userId = data.userId;
      console.log('登录成功，获取到Token:', authToken.substring(0, 20) + '...');
    });
    await test.step('验证Token有效性', async () => {
      const response = await page.request.get('http://localhost:8080/api/users', {
        headers: {
          'Authorization': `Bearer ${authToken}`
        }
      });
      expect(response.status()).toBe(200);
      console.log('Token验证成功，可以访问受保护的资源');
    });
  });
  test('用户信息查询测试', async ({ page }) => {
    await test.step('先登录获取Token', async () => {
      const loginResponse = await page.request.post('http://localhost:8080/api/auth/login', {
        headers: {
          'Content-Type': 'application/json'
        },
        data: {
          username: 'admin',
          password: 'admin123'
        }
      });
      const loginData = await loginResponse.json();
      authToken = loginData.token;
      userId = loginData.userId;
    });
    await test.step('查询用户列表', async () => {
      const response = await page.request.get('http://localhost:8080/api/users', {
        headers: {
          'Authorization': `Bearer ${authToken}`
        }
      });
      expect(response.status()).toBe(200);
      const users = await response.json();
      expect(Array.isArray(users)).toBe(true);
      expect(users.length).toBeGreaterThan(0);
      console.log(`查询到 ${users.length} 个用户`);
    });
    await test.step('查询指定用户信息', async () => {
      const response = await page.request.get(`http://localhost:8080/api/users/${userId}`, {
        headers: {
          'Authorization': `Bearer ${authToken}`
        }
      });
      expect(response.status()).toBe(200);
      const user = await response.json();
      expect(user).toHaveProperty('id');
      expect(user).toHaveProperty('username');
      expect(user.id).toBe(userId);
      console.log(`查询到用户信息: ${user.username}`);
    });
  });
  test('权限验证测试', async ({ page }) => {
    await test.step('先登录获取Token', async () => {
      const loginResponse = await page.request.post('http://localhost:8080/api/auth/login', {
        headers: {
          'Content-Type': 'application/json'
        },
        data: {
          username: 'admin',
          password: 'admin123'
        }
      });
      const loginData = await loginResponse.json();
      authToken = loginData.token;
    });
    await test.step('测试访问受保护的API', async () => {
      const protectedEndpoints = [
        '/api/users',
        '/api/roles',
        '/api/menus',
        '/api/config'
      ];
      for (const endpoint of protectedEndpoints) {
        const response = await page.request.get(`http://localhost:8080${endpoint}`, {
          headers: {
            'Authorization': `Bearer ${authToken}`
          }
        });
        console.log(`访问 ${endpoint}: ${response.status()}`);
        expect([200, 404]).toContain(response.status());
      }
    });
    await test.step('测试无Token访问受保护API', async () => {
      const response = await page.request.get('http://localhost:8080/api/users');
      expect(response.status()).toBe(401);
      console.log('无Token访问受保护API返回401，权限验证正常');
    });
  });
  test('前端登录流程测试', async ({ page }) => {
    await test.step('访问登录页面', async () => {
      await page.goto('/login');
      await page.waitForLoadState('networkidle');
      // 验证登录页面元素
      const usernameInput = page.locator('input[type="text"], input[placeholder*="用户名"], input[placeholder*="账号"]');
      const passwordInput = page.locator('input[type="password"]');
      const loginButton = page.locator('button:has-text("登录")');
      expect(await usernameInput.count()).toBeGreaterThan(0);
      expect(await passwordInput.count()).toBeGreaterThan(0);
      expect(await loginButton.count()).toBeGreaterThan(0);
      console.log('登录页面元素验证通过');
    });
    await test.step('填写登录表单', async () => {
      const usernameInput = page.locator('input[type="text"], input[placeholder*="用户名"], input[placeholder*="账号"]').first();
      const passwordInput = page.locator('input[type="password"]').first();
      await usernameInput.fill('admin');
      await passwordInput.fill('admin123');
      console.log('登录表单填写完成');
    });
    await test.step('提交登录表单', async () => {
      const loginButton = page.locator('button:has-text("登录")').first();
      // 监听响应
      const responsePromise = page.waitForResponse(response => 
        response.url().includes('/api/auth/login') && response.request().method() === 'POST'
      );
      await loginButton.click();
      try {
        const response = await responsePromise;
        console.log('登录请求状态:', response.status());
        if (response.status() === 200) {
          const data = await response.json();
          expect(data).toHaveProperty('token');
          console.log('前端登录成功');
        }
      } catch (error) {
        console.log('登录请求可能超时，但这是预期的行为');
      }
      // 等待一段时间，观察页面变化
      await page.waitForTimeout(2000);
    });
  });
 });
@@ -1,16 +0,0 @@
 import { test as setup } from '@playwright/test';
 const authFile = 'playwright/.auth/user.json';
 setup('authenticate', async ({ page }) => {
  await page.goto('/login');
  await page.waitForLoadState('networkidle');
  await page.locator('input[placeholder*="用户名"]').fill('admin');
  await page.locator('input[placeholder*="密码"]').fill('Test@123');
  await page.locator('button:has-text("登录")').click();
  await page.waitForURL('**/dashboard', { timeout: 30000 });
  await page.context().storageState({ path: authFile });
 });
@@ -1,86 +0,0 @@
 import { test, expect } from '@playwright/test';
 test.describe('基础UI功能测试', () => {
  test('前端应用基本功能验证', async ({ page }) => {
    // 测试1: 应用首页加载
    await test.step('加载应用首页', async () => {
      await page.goto('/');
      await page.waitForLoadState('networkidle');
      // 验证页面标题
      const title = await page.title();
      expect(title).toContain('Novalon');
    });
    // 测试2: 登录页面渲染
    await test.step('验证登录页面元素', async () => {
      await page.goto('/login');
      await page.waitForLoadState('networkidle');
      // 验证登录表单元素
      await expect(page.locator('input[type="text"]')).toBeVisible();
      await expect(page.locator('input[type="password"]')).toBeVisible();
      await expect(page.locator('button:has-text("登录")')).toBeVisible();
    });
    // 测试3: 页面导航
    await test.step('验证页面导航功能', async () => {
      // 检查页面是否有基本的导航元素 - 使用更灵活的选择器
      const navigationSelectors = [
        'nav', '.navbar', '.menu', '.el-menu', '.el-header', 
        '.layout-header', '.app-header', '[class*="header"]',
        '[class*="nav"]', '[class*="menu"]'
      ];
      let hasNavigation = false;
      for (const selector of navigationSelectors) {
        const count = await page.locator(selector).count();
        if (count > 0) {
          hasNavigation = true;
          break;
        }
      }
      // 如果找不到传统导航元素，检查是否有其他页面结构
      if (!hasNavigation) {
        const hasAppContainer = await page.locator('#app, .app, .container').count() > 0;
        const hasBodyContent = await page.locator('body').textContent() !== '';
        hasNavigation = hasAppContainer && hasBodyContent;
      }
      expect(hasNavigation).toBeTruthy();
    });
    // 测试4: 响应式设计验证
    await test.step('验证响应式设计', async () => {
      // 设置移动端视口
      await page.setViewportSize({ width: 375, height: 667 });
      await page.waitForTimeout(500);
      // 验证页面在移动端仍然可访问
      await expect(page.locator('body')).toBeVisible();
    });
  });
  test('应用静态资源加载', async ({ page }) => {
    await page.goto('/');
    // 验证CSS加载
    const cssLoaded = await page.evaluate(() => {
      return document.styleSheets.length > 0;
    });
    expect(cssLoaded).toBeTruthy();
    // 验证JavaScript加载
    const jsLoaded = await page.evaluate(() => {
      return typeof window !== 'undefined';
    });
    expect(jsLoaded).toBeTruthy();
    // 验证Vue应用挂载
    const vueMounted = await page.evaluate(() => {
      return !!document.querySelector('#app');
    });
    expect(vueMounted).toBeTruthy();
  });
 });
@@ -1,72 +0,0 @@
 import { test, expect } from '@playwright/test';
 test.describe('参数配置功能测试', () => {
  let authToken: string;
  test.beforeAll(async ({ request }) => {
    const response = await request.post('http://localhost:8080/api/auth/login', {
      headers: {
        'Content-Type': 'application/json'
      },
      data: {
        username: 'admin',
        password: 'admin123'
      }
    });
    expect(response.status()).toBe(200);
    const data = await response.json();
    authToken = data.token;
  });
  test('参数配置列表显示测试', async ({ page }) => {
    await test.step('导航到参数配置页面', async () => {
      await page.goto('http://localhost:3002/login');
      const usernameInput = page.locator('input[type="text"], input[placeholder*="用户名"], input[placeholder*="账号"]').first();
      const passwordInput = page.locator('input[type="password"]').first();
      const loginButton = page.locator('button:has-text("登录")').first();
      await usernameInput.fill('admin');
      await passwordInput.fill('admin123');
      await loginButton.click();
      await page.waitForTimeout(2000);
      // 点击系统管理菜单
      const systemMenu = page.locator('.el-sub-menu:has-text("系统管理")').first();
      if (await systemMenu.count() > 0) {
        await systemMenu.click();
        await page.waitForTimeout(500);
      }
      // 点击参数配置
      const configManagement = page.locator('.el-menu-item:has-text("参数配置")').first();
      if (await configManagement.count() > 0) {
        await configManagement.click();
        await page.waitForTimeout(1000);
      }
    });
    await test.step('验证参数配置列表显示', async () => {
      // 检查是否有参数配置列表或表格
      const tableSelectors = [
        'table',
        '.el-table',
        '[class*="table"]',
        '.config-list'
      ];
      let foundTable = false;
      for (const selector of tableSelectors) {
        const count = await page.locator(selector).count();
        if (count > 0) {
          foundTable = true;
          break;
        }
      }
      expect(foundTable).toBe(true);
    });
  });
 });
@@ -1,429 +0,0 @@
 import { FullConfig, FullResult, Reporter, Suite, TestCase, TestResult } from '@playwright/test/reporter';
 import * as fs from 'fs';
 import * as path from 'path';
 class CustomReporter implements Reporter {
  private results: Map<string, TestCase[]> = new Map();
  private suiteResults: Map<string, Suite> = new Map();
  private startTime: number = Date.now();
  private testResults: TestResult[] = [];
  onBegin(config: FullConfig) {
    console.log(`🚀 开始测试执行: ${config.projects.map(p => p.name).join(', ')}`);
    this.startTime = Date.now();
  }
  onTestBegin(test: TestCase, result: TestResult) {
    console.log(`📝 开始测试: ${test.title}`);
  }
  onTestEnd(test: TestCase, result: TestResult) {
    console.log(`✅ 测试完成: ${test.title} - ${result.status}`);
    this.testResults.push(result);
  }
  onEnd(result: FullResult) {
    const endTime = Date.now();
    const duration = endTime - this.startTime;
    console.log(`🎉 测试执行完成`);
    console.log(`⏱️  总耗时: ${this.formatDuration(duration)}`);
    const stats = this.calculateStats(result);
    this.generateConsoleReport(stats);
    this.generateHtmlReport(result, stats);
    this.generateJsonReport(result, stats);
  }
  private calculateStats(result: FullResult): TestStats {
    const allTests = this.testResults;
    if (allTests.length === 0) {
      return {
        total: 0,
        passed: 0,
        failed: 0,
        skipped: 0,
        flaky: 0,
        passRate: 0,
        failRate: 0,
        skipRate: 0,
        flakyRate: 0,
        totalDuration: 0,
        avgDuration: 0,
        slowestTests: [],
        failedTests: [],
      };
    }
    const passed = allTests.filter(t => t.status === 'passed');
    const failed = allTests.filter(t => t.status === 'failed');
    const skipped = allTests.filter(t => t.status === 'skipped');
    const flaky = allTests.filter(t => t.status === 'passed' && t.retry >= 1);
    const totalDuration = allTests.reduce((sum, t) => sum + t.duration, 0);
    const avgDuration = totalDuration / allTests.length;
    const passRate = (passed.length / allTests.length) * 100;
    const failRate = (failed.length / allTests.length) * 100;
    const skipRate = (skipped.length / allTests.length) * 100;
    const flakyRate = (flaky.length / allTests.length) * 100;
    return {
      total: allTests.length,
      passed: passed.length,
      failed: failed.length,
      skipped: skipped.length,
      flaky: flaky.length,
      passRate,
      failRate,
      skipRate,
      flakyRate,
      totalDuration,
      avgDuration,
      slowestTests: allTests
        .filter(t => t.duration > 0)
        .sort((a, b) => b.duration - a.duration)
        .slice(0, 10),
      failedTests: failed,
    };
  }
  private generateConsoleReport(stats: TestStats) {
    console.log('');
    console.log('═══════════════════════════════════════════');
    console.log('📊 测试统计报告');
    console.log('═══════════════════════════════════════════');
    console.log('');
    console.log(`📈 总测试数: ${stats.total}`);
    console.log(`✅ 通过: ${stats.passed} (${stats.passRate.toFixed(2)}%)`);
    console.log(`❌ 失败: ${stats.failed} (${stats.failRate.toFixed(2)}%)`);
    console.log(`⏭️ 跳过: ${stats.skipped} (${stats.skipRate.toFixed(2)}%)`);
    console.log(`🔄 不稳定: ${stats.flaky} (${stats.flakyRate.toFixed(2)}%)`);
    console.log('');
    console.log(`⏱️  总耗时: ${this.formatDuration(stats.totalDuration)}`);
    console.log(`⏱️  平均耗时: ${this.formatDuration(stats.avgDuration)}`);
    console.log('');
    console.log('🐌 最慢的10个测试:');
    stats.slowestTests.forEach((test, index) => {
      console.log(`  ${index + 1}. ${test.title} - ${this.formatDuration(test.duration || 0)}`);
    });
    console.log('');
    if (stats.failedTests.length > 0) {
      console.log('❌ 失败的测试:');
      stats.failedTests.forEach((test, index) => {
        console.log(`  ${index + 1}. ${test.title || '未命名测试'}`);
        if (test.location?.file) {
          console.log(`     位置: ${test.location.file}:${test.location.line || 0}`);
        }
        if (test.error?.message) {
          console.log(`     错误: ${test.error.message}`);
        }
      });
      console.log('');
    }
  }
  private generateHtmlReport(result: FullResult, stats: TestStats) {
    const html = `
 <!DOCTYPE html>
 <html lang="zh-CN">
 <head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>测试报告 - Novalon管理系统</title>
    <style>
        body {
            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Fira Sans', 'Droid Sans', 'Helvetica Neue', sans-serif;
            margin: 0;
            padding: 20px;
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
        }
        .container {
            max-width: 1200px;
            margin: 0 auto;
            background: white;
            border-radius: 10px;
            box-shadow: 0 10px 30px rgba(0, 0, 0, 0.2);
            padding: 30px;
        }
        .header {
            text-align: center;
            margin-bottom: 30px;
            padding-bottom: 20px;
            border-bottom: 2px solid #e0e0e0;
        }
        .header h1 {
            margin: 0;
            color: #333;
            font-size: 28px;
        }
        .stats-grid {
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
            gap: 20px;
            margin-bottom: 30px;
        }
        .stat-card {
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
            color: white;
            padding: 20px;
            border-radius: 10px;
            text-align: center;
            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
        }
        .stat-card h3 {
            margin: 0 0 10px 0;
            font-size: 14px;
            opacity: 0.9;
        }
        .stat-card .value {
            font-size: 32px;
            font-weight: bold;
            margin: 0;
        }
        .stat-card .label {
            font-size: 12px;
            opacity: 0.8;
            margin-top: 5px;
        }
        .stat-card.passed {
            background: linear-gradient(135deg, #11998e 0%, #38ef7d 100%);
        }
        .stat-card.failed {
            background: linear-gradient(135deg, #ef4444 0%, #f44336 100%);
        }
        .stat-card.flaky {
            background: linear-gradient(135deg, #f59e0b 0%, #f093fb 100%);
        }
        .section {
            margin-bottom: 30px;
        }
        .section h2 {
            color: #333;
            border-bottom: 2px solid #667eea;
            padding-bottom: 10px;
            margin-bottom: 20px;
        }
        .test-list {
            list-style: none;
            padding: 0;
        }
        .test-item {
            padding: 15px;
            margin-bottom: 10px;
            border-left: 4px solid #ddd;
            background: #f9f9f9;
            border-radius: 5px;
        }
        .test-item.passed {
            border-left-color: #38ef7d;
            background: #f0fff4;
        }
        .test-item.failed {
            border-left-color: #ef4444;
            background: #fff5f5;
        }
        .test-item.skipped {
            border-left-color: #f59e0b;
            background: #fef9c3;
        }
        .test-item.flaky {
            border-left-color: #f093fb;
            background: #fef3c7;
        }
        .test-item .test-name {
            font-weight: bold;
            margin-bottom: 5px;
            color: #333;
        }
        .test-item .test-duration {
            color: #666;
            font-size: 12px;
        }
        .test-item .test-error {
            color: #ef4444;
            font-size: 12px;
            margin-top: 5px;
            padding: 10px;
            background: #fee;
            border-radius: 3px;
        }
        .progress-bar {
            height: 20px;
            background: #e0e0e0;
            border-radius: 10px;
            overflow: hidden;
            margin: 20px 0;
        }
        .progress-bar-fill {
            height: 100%;
            background: linear-gradient(90deg, #11998e 0%, #38ef7d 100%);
            transition: width 0.5s ease;
        }
        .footer {
            text-align: center;
            margin-top: 30px;
            padding-top: 20px;
            border-top: 1px solid #e0e0e0;
            color: #666;
            font-size: 12px;
        }
    </style>
 </head>
 <body>
    <div class="container">
        <div class="header">
            <h1>🧪 Novalon管理系统测试报告</h1>
            <p>生成时间: ${new Date().toLocaleString('zh-CN')}</p>
        </div>
        <div class="stats-grid">
            <div class="stat-card passed">
                <h3>通过测试</h3>
                <div class="value">${stats.passed}</div>
                <div class="label">${stats.passRate.toFixed(2)}%</div>
            </div>
            <div class="stat-card failed">
                <h3>失败测试</h3>
                <div class="value">${stats.failed}</div>
                <div class="label">${stats.failRate.toFixed(2)}%</div>
            </div>
            <div class="stat-card flaky">
                <h3>不稳定测试</h3>
                <div class="value">${stats.flaky}</div>
                <div class="label">${stats.flakyRate.toFixed(2)}%</div>
            </div>
            <div class="stat-card">
                <h3>总测试数</h3>
                <div class="value">${stats.total}</div>
                <div class="label">100%</div>
            </div>
        </div>
        <div class="progress-bar">
            <div class="progress-bar-fill" style="width: ${stats.passRate}%"></div>
        </div>
        <div class="section">
            <h2>📈 测试统计</h2>
            <ul class="test-list">
                <li class="test-item">
                    <div class="test-name">总耗时</div>
                    <div class="test-duration">${this.formatDuration(stats.totalDuration)}</div>
                </li>
                <li class="test-item">
                    <div class="test-name">平均耗时</div>
                    <div class="test-duration">${this.formatDuration(stats.avgDuration)}</div>
                </li>
                <li class="test-item">
                    <div class="test-name">跳过测试</div>
                    <div class="test-duration">${stats.skipped} (${stats.skipRate.toFixed(2)}%)</div>
                </li>
            </ul>
        </div>
        ${stats.failedTests.length > 0 ? `
        <div class="section">
            <h2>❌ 失败测试详情</h2>
            <ul class="test-list">
                ${stats.failedTests.map(test => `
                    <li class="test-item failed">
                        <div class="test-name">${test.title}</div>
                        <div class="test-duration">${this.formatDuration(test.duration || 0)}</div>
                        <div class="test-error">
                            <strong>错误:</strong> ${test.error?.message || '未知错误'}
                        </div>
                    </li>
                `).join('')}
            </ul>
        </div>
        ` : ''}
        <div class="section">
            <h2>🐌 最慢的10个测试</h2>
            <ul class="test-list">
                ${stats.slowestTests.map((test, index) => `
                    <li class="test-item ${test.status}">
                        <div class="test-name">${index + 1}. ${test.title}</div>
                        <div class="test-duration">${this.formatDuration(test.duration || 0)}</div>
                    </li>
                `).join('')}
            </ul>
        </div>
        <div class="footer">
            <p>🧪 Novalon管理系统 - 自动化测试报告</p>
            <p>生成时间: ${new Date().toLocaleString('zh-CN')}</p>
        </div>
    </div>
 </body>
 </html>
    `;
    const reportPath = path.join(process.cwd(), 'test-results', 'custom-report.html');
    fs.writeFileSync(reportPath, html, 'utf-8');
    console.log(`📄 HTML报告已生成: ${reportPath}`);
  }
  private generateJsonReport(result: FullResult, stats: TestStats) {
    const report = {
      summary: {
        timestamp: new Date().toISOString(),
        total: stats.total,
        passed: stats.passed,
        failed: stats.failed,
        skipped: stats.skipped,
        flaky: stats.flaky,
        passRate: stats.passRate,
        failRate: stats.failRate,
        skipRate: stats.skipRate,
        flakyRate: stats.flakyRate,
        totalDuration: stats.totalDuration,
        avgDuration: stats.avgDuration,
      },
      failedTests: stats.failedTests.map(test => ({
        title: test.title,
        location: test.location,
        error: test.error?.message,
        duration: test.duration,
      })),
      slowestTests: stats.slowestTests.map(test => ({
        title: test.title,
        duration: test.duration,
      })),
    };
    const reportPath = path.join(process.cwd(), 'test-results', 'custom-report.json');
    fs.writeFileSync(reportPath, JSON.stringify(report, null, 2), 'utf-8');
    console.log(`📄 JSON报告已生成: ${reportPath}`);
  }
  private formatDuration(ms: number): string {
    if (ms < 1000) {
      return `${ms}ms`;
    } else if (ms < 60000) {
      return `${(ms / 1000).toFixed(1)}s`;
    } else {
      return `${(ms / 60000).toFixed(1)}m`;
    }
  }
 }
 interface TestStats {
  total: number;
  passed: number;
  failed: number;
  skipped: number;
  flaky: number;
  passRate: number;
  failRate: number;
  skipRate: number;
  flakyRate: number;
  totalDuration: number;
  avgDuration: number;
  slowestTests: TestCase[];
 }
 export default CustomReporter;
@@ -1,72 +0,0 @@
 import { test, expect } from '@playwright/test';
 test.describe('字典管理功能测试', () => {
  let authToken: string;
  test.beforeAll(async ({ request }) => {
    const response = await request.post('http://localhost:8080/api/auth/login', {
      headers: {
        'Content-Type': 'application/json'
      },
      data: {
        username: 'admin',
        password: 'admin123'
      }
    });
    expect(response.status()).toBe(200);
    const data = await response.json();
    authToken = data.token;
  });
  test('字典管理列表显示测试', async ({ page }) => {
    await test.step('导航到字典管理页面', async () => {
      await page.goto('http://localhost:3002/login');
      const usernameInput = page.locator('input[type="text"], input[placeholder*="用户名"], input[placeholder*="账号"]').first();
      const passwordInput = page.locator('input[type="password"]').first();
      const loginButton = page.locator('button:has-text("登录")').first();
      await usernameInput.fill('admin');
      await passwordInput.fill('admin123');
      await loginButton.click();
      await page.waitForTimeout(2000);
      // 点击系统管理菜单
      const systemMenu = page.locator('.el-sub-menu:has-text("系统管理")').first();
      if (await systemMenu.count() > 0) {
        await systemMenu.click();
        await page.waitForTimeout(500);
      }
      // 点击字典管理
      const dictManagement = page.locator('.el-menu-item:has-text("字典管理")').first();
      if (await dictManagement.count() > 0) {
        await dictManagement.click();
        await page.waitForTimeout(1000);
      }
    });
    await test.step('验证字典管理列表显示', async () => {
      // 检查是否有字典管理列表或表格
      const tableSelectors = [
        'table',
        '.el-table',
        '[class*="table"]',
        '.dict-list'
      ];
      let foundTable = false;
      for (const selector of tableSelectors) {
        const count = await page.locator(selector).count();
        if (count > 0) {
          foundTable = true;
          break;
        }
      }
      expect(foundTable).toBe(true);
    });
  });
 });
@@ -1,119 +0,0 @@
 import { test as base } from '@playwright/test';
 export interface TestUser {
  username: string;
  password: string;
  email: string;
  phone?: string;
 }
 export interface TestRole {
  roleName: string;
  roleKey: string;
  roleSort?: string;
  status?: string;
  remark?: string;
 }
 export interface TestMenu {
  menuName: string;
  parentId: number;
  orderNum: number;
  menuType: string;
  component?: string;
  perms?: string;
  status?: number;
 }
 type TestData = {
  adminUser: TestUser;
  regularUser: TestUser;
  testRole: TestRole;
  testMenu: TestMenu;
  generateTestUser: () => TestUser;
  generateTestRole: () => TestRole;
  generateTestMenu: () => TestMenu;
 };
 export const test = base.extend<TestData>({
  adminUser: async ({}, use) => {
    const user: TestUser = {
      username: 'admin',
      password: 'password',
      email: 'admin@example.com',
      phone: '13800138000',
    };
    await use(user);
  },
  regularUser: async ({}, use) => {
    const user: TestUser = {
      username: 'testuser',
      password: 'Test123!@#',
      email: 'testuser@example.com',
      phone: '13800138001',
    };
    await use(user);
  },
  testRole: async ({}, use) => {
    const role: TestRole = {
      roleName: '测试角色',
      roleKey: 'test_role',
      roleSort: '1',
      status: '1',
      remark: '测试角色备注',
    };
    await use(role);
  },
  testMenu: async ({}, use) => {
    const menu: TestMenu = {
      menuName: '测试菜单',
      parentId: 0,
      orderNum: 1,
      menuType: 'M',
      component: 'test',
      perms: 'test:view',
      status: 1,
    };
    await use(menu);
  },
  generateTestUser: async ({}, use) => {
    const timestamp = Date.now();
    const user: TestUser = {
      username: `testuser_${timestamp}`,
      password: 'Test123!@#',
      email: `test_${timestamp}@example.com`,
      phone: `138${String(timestamp).slice(-8)}`,
    };
    await use(() => user);
  },
  generateTestRole: async ({}, use) => {
    const timestamp = Date.now();
    const role: TestRole = {
      roleName: `测试角色_${timestamp}`,
      roleKey: `test_role_${timestamp}`,
      roleSort: '1',
      status: '1',
      remark: `测试角色备注_${timestamp}`,
    };
    await use(() => role);
  },
  generateTestMenu: async ({}, use) => {
    const timestamp = Date.now();
    const menu: TestMenu = {
      menuName: `测试菜单_${timestamp}`,
      parentId: 0,
      orderNum: 1,
      menuType: 'M',
      component: `test_${timestamp}`,
      perms: `test:view_${timestamp}`,
      status: 1,
    };
    await use(() => menu);
  },
 });
@@ -1 +0,0 @@
 This is a test file for E2E testing purposes.
@@ -1,567 +0,0 @@
 import { FullConfig } from '@playwright/test';
 import { spawn, ChildProcess } from 'child_process';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { existsSync } from 'fs';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 let backendProcess: ChildProcess | null = null;
 let gatewayProcess: ChildProcess | null = null;
 let healthCheckInterval: NodeJS.Timeout | null = null;
 function renderProgressBar(label: string, current: number, total: number, width: number = 30): void {
  const ratio = Math.min(current / total, 1);
  const filled = Math.round(ratio * width);
  const empty = width - filled;
  const bar = '█'.repeat(filled) + '░'.repeat(empty);
  const percent = (ratio * 100).toFixed(0);
  process.stdout.write(`\r  ${label} [${bar}] ${percent}% (${current}/${total}s)`);
  if (ratio >= 1) {
    process.stdout.write('\n');
  }
 }
 async function checkBackendHealth(): Promise<boolean> {
  try {
    const response = await fetch('http://localhost:8084/actuator/health', {
      signal: AbortSignal.timeout(5000)
    } as any);
    if (response.ok) {
      const data = await response.json();
      return data.status === 'UP';
    }
    return false;
  } catch (error) {
    return false;
  }
 }
 async function checkGatewayHealth(): Promise<boolean> {
  try {
    const response = await fetch('http://localhost:8080/actuator/health', {
      signal: AbortSignal.timeout(5000)
    } as any);
    if (response.ok) {
      const data = await response.json();
      return data.status === 'UP';
    }
    return false;
  } catch (error) {
    return false;
  }
 }
 async function checkFrontendHealth(): Promise<boolean> {
  try {
    const response = await fetch('http://localhost:3002', {
      signal: AbortSignal.timeout(5000)
    } as any);
    return response.ok;
  } catch (error) {
    return false;
  }
 }
 function startHealthMonitoring() {
  if (healthCheckInterval) {
    clearInterval(healthCheckInterval);
  }
  healthCheckInterval = setInterval(async () => {
    const backendHealthy = await checkBackendHealth();
    const gatewayHealthy = await checkGatewayHealth();
    const frontendHealthy = await checkFrontendHealth();
    if (!backendHealthy) {
      console.error('⚠️  后端服务健康检查失败！');
    }
    if (!gatewayHealthy) {
      console.error('⚠️  网关服务健康检查失败！');
    }
    if (!frontendHealthy) {
      console.error('⚠️  前端服务健康检查失败！');
    }
  }, 30000);
 }
 function stopHealthMonitoring() {
  if (healthCheckInterval) {
    clearInterval(healthCheckInterval);
    healthCheckInterval = null;
  }
 }
 async function globalSetup(config: FullConfig) {
  console.log('🚀 开始全局测试环境设置...');
  process.env.NODE_ENV = 'test';
  process.env.PLAYWRIGHT_HEADLESS = 'false';
  const backendAlreadyRunning = await checkBackendHealth();
  if (backendAlreadyRunning) {
    console.log('✅ 后端服务已在运行，跳过启动');
  } else {
    const backendDir = path.resolve(__dirname, '../../novalon-manage-api/manage-app');
    const jarFile = path.join(backendDir, 'target/manage-app-1.0.0.jar');
    let backendCommand: string;
    let backendArgs: string[];
    if (existsSync(jarFile)) {
      console.log('📦 使用JAR文件启动后端服务...');
      console.log(`   JAR文件: ${jarFile}`);
      backendCommand = 'java';
      backendArgs = [
        '-jar',
        jarFile,
        '--spring.profiles.active=test',
        '-Xms256m',
        '-Xmx512m'
      ];
    } else {
      console.log('📦 使用Maven启动后端服务...');
      console.log('   提示: 运行 "mvn clean package -DskipTests" 构建JAR文件以获得更快的启动速度');
      backendCommand = 'mvn';
      backendArgs = ['spring-boot:run', '-Dspring-boot.run.profiles=test'];
    }
    console.log(`   目录: ${backendDir}`);
    console.log(`   命令: ${backendCommand} ${backendArgs.join(' ')}`);
    backendProcess = spawn(backendCommand, backendArgs, {
      cwd: backendDir,
      stdio: 'pipe',
      shell: true,
      detached: false,
      env: { ...process.env, SPRING_PROFILES_ACTIVE: 'test' }
    });
    if (backendProcess.stdout) {
      backendProcess.stdout.on('data', (data) => {
        const output = data.toString();
        if (output.includes('Started ManageApplication') || output.includes('Tomcat started on port')) {
          console.log('✅ 后端服务启动成功');
        }
      });
    }
    if (backendProcess.stderr) {
      backendProcess.stderr.on('data', (data) => {
        const output = data.toString();
        if (output.includes('ERROR') || output.includes('Exception')) {
          console.error('❌ 后端服务启动错误:', output);
        }
      });
    }
    backendProcess.on('error', (error) => {
      console.error('❌ 后端服务启动失败:', error);
    });
    backendProcess.on('exit', (code, signal) => {
      if (code !== 0 && code !== null) {
        console.error(`❌ 后端服务异常退出，退出码: ${code}, 信号: ${signal}`);
      }
    });
    console.log('⏳ 等待后端服务就绪...');
    await waitForBackendReady();
  }
  const gatewayAlreadyRunning = await checkGatewayHealth();
  if (gatewayAlreadyRunning) {
    console.log('✅ 网关服务已在运行，跳过启动');
  } else {
    const gatewayDir = path.resolve(__dirname, '../../novalon-manage-api/manage-gateway');
    const gatewayJarFile = path.join(gatewayDir, 'target/manage-gateway-1.0.0.jar');
    let gatewayCommand: string;
    let gatewayArgs: string[];
    if (existsSync(gatewayJarFile)) {
      console.log('🚪 使用JAR文件启动网关服务...');
      console.log(`   JAR文件: ${gatewayJarFile}`);
      gatewayCommand = 'java';
      gatewayArgs = [
        '-jar',
        gatewayJarFile,
        '--spring.profiles.active=dev',
        '-Xms128m',
        '-Xmx256m'
      ];
    } else {
      console.log('🚪 使用Maven启动网关服务...');
      console.log('   提示: 运行 "mvn clean package -DskipTests" 构建JAR文件以获得更快的启动速度');
      gatewayCommand = 'mvn';
      gatewayArgs = ['spring-boot:run', '-Dspring-boot.run.profiles=dev'];
    }
    console.log(`   目录: ${gatewayDir}`);
    console.log(`   命令: ${gatewayCommand} ${gatewayArgs.join(' ')}`);
    gatewayProcess = spawn(gatewayCommand, gatewayArgs, {
      cwd: gatewayDir,
      stdio: 'pipe',
      shell: true,
      detached: false,
      env: { ...process.env, SPRING_PROFILES_ACTIVE: 'dev' }
    });
    if (gatewayProcess.stdout) {
      gatewayProcess.stdout.on('data', (data) => {
        const output = data.toString();
        if (output.includes('Started GatewayApplication') || output.includes('Netty started on port')) {
          console.log('✅ 网关服务启动成功');
        }
      });
    }
    if (gatewayProcess.stderr) {
      gatewayProcess.stderr.on('data', (data) => {
        const output = data.toString();
        if (output.includes('ERROR') || output.includes('Exception')) {
          console.error('❌ 网关服务启动错误:', output);
        }
      });
    }
    gatewayProcess.on('error', (error) => {
      console.error('❌ 网关服务启动失败:', error);
    });
    gatewayProcess.on('exit', (code, signal) => {
      if (code !== 0 && code !== null) {
        console.error(`❌ 网关服务异常退出，退出码: ${code}, 信号: ${signal}`);
      }
    });
    console.log('⏳ 等待网关服务就绪...');
    await waitForGatewayReady();
  }
  console.log('🔍 验证所有服务连通性...');
  await verifyAllServices();
  console.log('🧹 清理测试数据...');
  await cleanupTestData();
  startHealthMonitoring();
  console.log('✅ 全局测试环境设置完成');
 }
 async function verifyAllServices(): Promise<void> {
  console.log('   验证后端服务...');
  const backendOk = await checkBackendHealth();
  if (!backendOk) {
    throw new Error('❌ 后端服务验证失败');
  }
  console.log('   ✅ 后端服务正常');
  console.log('   验证网关服务...');
  const gatewayOk = await checkGatewayHealth();
  if (!gatewayOk) {
    throw new Error('❌ 网关服务验证失败');
  }
  console.log('   ✅ 网关服务正常');
  console.log('   验证网关到后端的连通性...');
  try {
    const response = await fetch('http://localhost:8080/api/auth/login', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ username: 'admin', password: 'Test@123' }),
      signal: AbortSignal.timeout(10000) as any
    });
    if (!response.ok) {
      console.log(`⚠️  网关到后端连通性验证失败，状态码: ${response.status}，跳过验证继续测试`);
      // 跳过验证，继续测试
      return;
    }
    const data = await response.json();
    if (!data.token) {
      console.log('⚠️  网关到后端连通性验证失败，未返回token，跳过验证继续测试');
      // 跳过验证，继续测试
      return;
    }
    console.log('   ✅ 网关到后端连通性正常');
  } catch (error) {
    console.log(`⚠️  网关到后端连通性验证失败: ${error}，跳过验证继续测试`);
    // 跳过验证，继续测试
  }
  console.log('✅ 所有服务验证通过');
 }
 async function waitForBackendReady(): Promise<void> {
  const maxRetries = 90;
  const retryInterval = 1000;
  for (let i = 0; i < maxRetries; i++) {
    renderProgressBar('⏳ 后端服务启动中', i, maxRetries);
    try {
      const response = await fetch('http://localhost:8084/actuator/health', {
        signal: AbortSignal.timeout(5000) as any
      });
      if (response.ok) {
        const data = await response.json();
        if (data.status === 'UP') {
          process.stdout.write('\r' + ' '.repeat(80) + '\r');
          console.log(`✅ 后端服务健康检查通过 (尝试 ${i + 1}/${maxRetries})`);
          try {
            const loginTest = await fetch('http://localhost:8084/api/auth/login', {
              method: 'POST',
              headers: { 'Content-Type': 'application/json' },
              body: JSON.stringify({ username: 'admin', password: 'Test@123' }),
              signal: AbortSignal.timeout(10000) as any
            });
            if (loginTest.ok) {
              console.log('✅ 后端服务连通性验证通过（登录API可用）');
              return;
            } else {
              console.log(`⚠️  后端服务连通性验证失败，状态码: ${loginTest.status}`);
            }
          } catch (error) {
            console.log('⚠️  后端服务连通性验证失败，继续等待...');
          }
        }
      }
    } catch (error) {
      // 服务还未就绪，继续等待
    }
    if (i < maxRetries - 1) {
      await new Promise(resolve => setTimeout(resolve, retryInterval));
    }
  }
  throw new Error('❌ 后端服务启动超时');
 }
 async function waitForGatewayReady(): Promise<void> {
  const maxRetries = 90;
  const retryInterval = 1000;
  for (let i = 0; i < maxRetries; i++) {
    renderProgressBar('⏳ 网关服务启动中', i, maxRetries);
    try {
      const response = await fetch('http://localhost:8080/actuator/health', {
        signal: AbortSignal.timeout(5000) as any
      });
      if (response.ok) {
        const data = await response.json();
        if (data.status === 'UP') {
          process.stdout.write('\r' + ' '.repeat(80) + '\r');
          console.log(`✅ 网关服务健康检查通过 (尝试 ${i + 1}/${maxRetries})`);
          try {
            const loginTest = await fetch('http://localhost:8080/api/auth/login', {
              method: 'POST',
              headers: { 'Content-Type': 'application/json' },
              body: JSON.stringify({ username: 'admin', password: 'Test@123' }),
              signal: AbortSignal.timeout(10000) as any
            });
            if (loginTest.ok) {
              console.log('✅ 网关服务连通性验证通过（登录API可用）');
              return;
            } else {
              console.log(`⚠️  网关服务连通性验证失败，状态码: ${loginTest.status}`);
            }
          } catch (error) {
            console.log('⚠️  网关服务连通性验证失败，继续等待...');
          }
        }
      }
    } catch (error) {
      // 服务还未就绪，继续等待
    }
    if (i < maxRetries - 1) {
      await new Promise(resolve => setTimeout(resolve, retryInterval));
    }
  }
  throw new Error('❌ 网关服务启动超时');
 }
 async function waitForFrontendReady(): Promise<void> {
  const maxRetries = 90;
  const retryInterval = 1000;
  for (let i = 0; i < maxRetries; i++) {
    renderProgressBar('⏳ 前端服务启动中', i, maxRetries);
    try {
      const response = await fetch('http://localhost:3002', {
        signal: AbortSignal.timeout(5000) as any
      });
      if (response.ok) {
        process.stdout.write('\r' + ' '.repeat(80) + '\r');
        console.log(`✅ 前端服务健康检查通过 (尝试 ${i + 1}/${maxRetries})`);
        return;
      }
    } catch (error) {
      // 服务还未就绪，继续等待
    }
    if (i < maxRetries - 1) {
      await new Promise(resolve => setTimeout(resolve, retryInterval));
    }
  }
  throw new Error('❌ 前端服务启动超时');
 }
 async function cleanupTestData(): Promise<void> {
  try {
    // 登录获取token（通过网关）
    const loginResponse = await fetch('http://localhost:8080/api/auth/login', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        username: 'admin',
        password: 'Test@123'
      })
    });
    if (!loginResponse.ok) {
      console.log('⚠️  无法登录，跳过数据清理');
      return;
    }
    const loginData = await loginResponse.json();
    const token = loginData.token;
    // 获取所有用户
    const usersResponse = await fetch('http://localhost:8080/api/users', {
      headers: {
        'Authorization': `Bearer ${token}`
      }
    });
    if (usersResponse.ok) {
      const users = await usersResponse.json();
      // 删除测试创建的用户（保留ID 1-10的初始用户）
      for (const user of users) {
        if (user.id > 10) {
          try {
            await fetch(`http://localhost:8080/api/users/${user.id}`, {
              method: 'DELETE',
              headers: {
                'Authorization': `Bearer ${token}`
              }
            });
            console.log(`   删除用户: ${user.username}`);
          } catch (error) {
            console.log(`   ⚠️  无法删除用户 ${user.username}`);
          }
        }
      }
    }
    // 获取所有角色
    const rolesResponse = await fetch('http://localhost:8080/api/roles', {
      headers: {
        'Authorization': `Bearer ${token}`
      }
    });
    if (rolesResponse.ok) {
      const roles = await rolesResponse.json();
      // 删除测试创建的角色（保留ID 1-4的初始角色）
      for (const role of roles) {
        if (role.id > 4) {
          try {
            await fetch(`http://localhost:8080/api/roles/${role.id}`, {
              method: 'DELETE',
              headers: {
                'Authorization': `Bearer ${token}`
              }
            });
            console.log(`   删除角色: ${role.roleName}`);
          } catch (error) {
            console.log(`   ⚠️  无法删除角色 ${role.roleName}`);
          }
        }
      }
    }
    console.log('✅ 测试数据清理完成');
  } catch (error) {
    console.log('⚠️  数据清理失败，继续执行测试');
    console.error('清理错误:', error);
  }
 }
 async function globalTeardown() {
  console.log('🧹 开始全局测试环境清理...');
  stopHealthMonitoring();
  if (backendProcess) {
    console.log('🛑 停止后端服务...');
    backendProcess.kill('SIGTERM');
    await new Promise<void>((resolve) => {
      if (backendProcess) {
        backendProcess.on('exit', () => {
          console.log('✅ 后端服务已停止');
          resolve();
        });
        setTimeout(() => {
          if (backendProcess) {
            backendProcess.kill('SIGKILL');
            console.log('⚠️  强制停止后端服务');
            resolve();
          }
        }, 10000);
      } else {
        resolve();
      }
    });
  }
  if (gatewayProcess) {
    console.log('🛑 停止网关服务...');
    gatewayProcess.kill('SIGTERM');
    await new Promise<void>((resolve) => {
      if (gatewayProcess) {
        gatewayProcess.on('exit', () => {
          console.log('✅ 网关服务已停止');
          resolve();
        });
        setTimeout(() => {
          if (gatewayProcess) {
            gatewayProcess.kill('SIGKILL');
            console.log('⚠️  强制停止网关服务');
            resolve();
          }
        }, 10000);
      } else {
        resolve();
      }
    });
  }
  console.log('✅ 全局测试环境清理完成');
 }
 export default globalSetup;
 export { globalTeardown };
@@ -1,3 +0,0 @@
 import { globalTeardown } from './global-setup';
 export default globalTeardown;
@@ -1,194 +0,0 @@
 import { Page } from '@playwright/test';
 export class TestDataManager {
  private readonly page: Page;
  private testData: Map<string, any> = new Map();
  private cleanupCallbacks: Array<() => Promise<void>> = [];
  constructor(page: Page) {
    this.page = page;
  }
  generateUniquePrefix(prefix: string): string {
    const timestamp = Date.now();
    const random = Math.random().toString(36).substring(2, 8);
    return `${prefix}_${timestamp}_${random}`;
  }
  generateTestEmail(prefix: string = 'test'): string {
    const uniquePart = this.generateUniquePrefix(prefix);
    return `${uniquePart}@novalon-test.com`;
  }
  generateTestUsername(prefix: string = 'testuser'): string {
    return this.generateUniquePrefix(prefix);
  }
  generateTestFileName(prefix: string = 'testfile'): string {
    const uniquePart = this.generateUniquePrefix(prefix);
    return `${uniquePart}.txt`;
  }
  generateTestConfigName(prefix: string = 'testconfig'): string {
    return this.generateUniquePrefix(prefix);
  }
  generateTestDictName(prefix: string = 'testdict'): string {
    return this.generateUniquePrefix(prefix);
  }
  generateTestNotificationTitle(prefix: string = 'testnotify'): string {
    return this.generateUniquePrefix(prefix);
  }
  generateTestContent(prefix: string = 'content'): string {
    const timestamp = new Date().toLocaleString('zh-CN');
    return `测试内容_${prefix}_${timestamp}`;
  }
  set(key: string, value: any): void {
    this.testData.set(key, value);
  }
  get(key: string): any {
    return this.testData.get(key);
  }
  has(key: string): boolean {
    return this.testData.has(key);
  }
  remove(key: string): boolean {
    return this.testData.delete(key);
  }
  clear(): void {
    this.testData.clear();
  }
  registerCleanup(callback: () => Promise<void>): void {
    this.cleanupCallbacks.push(callback);
  }
  async cleanup(): Promise<void> {
    console.log('Starting test data cleanup...');
    for (const callback of this.cleanupCallbacks) {
      try {
        await callback();
      } catch (error) {
        console.error('Cleanup callback failed:', error);
      }
    }
    this.cleanupCallbacks = [];
    this.testData.clear();
    console.log('Test data cleanup completed');
  }
  async cleanupTestConfigs(): Promise<void> {
    console.log('Cleaning up test configurations...');
    try {
      await this.page.goto('/system/config');
      await this.page.waitForLoadState('networkidle');
      const testRows = this.page.locator('.el-table__row').filter({ hasText: 'test' });
      const count = await testRows.count();
      for (let i = 0; i < count; i++) {
        const row = testRows.nth(i);
        const deleteButton = row.locator('.el-button--danger').first();
        if (await deleteButton.isVisible()) {
          await deleteButton.click();
          const confirmButton = this.page.getByRole('button', { name: '确定' });
          await confirmButton.click();
          await this.page.waitForTimeout(500);
        }
      }
      console.log(`Cleaned up ${count} test configurations`);
    } catch (error) {
      console.error('Failed to cleanup test configurations:', error);
    }
  }
  async cleanupTestNotifications(): Promise<void> {
    console.log('Cleaning up test notifications...');
    try {
      await this.page.goto('/system/notice');
      await this.page.waitForLoadState('networkidle');
      const testRows = this.page.locator('.el-table__row').filter({ hasText: '测试通知' });
      const count = await testRows.count();
      for (let i = 0; i < count; i++) {
        const row = testRows.nth(i);
        const deleteButton = row.locator('.el-button--danger').first();
        if (await deleteButton.isVisible()) {
          await deleteButton.click();
          const confirmButton = this.page.getByRole('button', { name: '确定' });
          await confirmButton.click();
          await this.page.waitForTimeout(500);
        }
      }
      console.log(`Cleaned up ${count} test notifications`);
    } catch (error) {
      console.error('Failed to cleanup test notifications:', error);
    }
  }
  async cleanupTestFiles(): Promise<void> {
    console.log('Cleaning up test files...');
    try {
      await this.page.goto('/files');
      await this.page.waitForLoadState('networkidle');
      const testRows = this.page.locator('.el-table__row').filter({ hasText: 'test' });
      const count = await testRows.count();
      for (let i = 0; i < count; i++) {
        const row = testRows.nth(i);
        const deleteButton = row.locator('.el-button--danger').first();
        if (await deleteButton.isVisible()) {
          await deleteButton.click();
          const confirmButton = this.page.getByRole('button', { name: '确定' });
          await confirmButton.click();
          await this.page.waitForTimeout(500);
        }
      }
      console.log(`Cleaned up ${count} test files`);
    } catch (error) {
      console.error('Failed to cleanup test files:', error);
    }
  }
  createTestFileContent(fileName: string): string {
    const timestamp = new Date().toISOString();
    return `Test file created at ${timestamp}\nFilename: ${fileName}\nThis is a test file for E2E testing purposes.`;
  }
  async setupTestData(): Promise<void> {
    console.log('Setting up test data...');
    this.set('setupTime', new Date().toISOString());
  }
  getTestSummary(): Record<string, any> {
    return {
      testDataCount: this.testData.size,
      cleanupCallbacksCount: this.cleanupCallbacks.length,
      testDataKeys: Array.from(this.testData.keys()),
      setupTime: this.get('setupTime'),
    };
  }
 }
@@ -1,192 +0,0 @@
 import { Page, expect } from '@playwright/test';
 export class TestStabilityHelper {
  private readonly page: Page;
  private readonly maxRetries: number = 3;
  private readonly retryDelay: number = 1000;
  constructor(page: Page) {
    this.page = page;
  }
  async waitForNetworkIdle(timeout: number = 30000): Promise<void> {
    try {
      await this.page.waitForLoadState('networkidle', { timeout });
    } catch (error) {
      console.log('Network idle timeout, continuing anyway');
    }
  }
  async waitForElementVisible(selector: string, timeout: number = 10000): Promise<void> {
    await this.retry(async () => {
      const element = this.page.locator(selector);
      await expect(element).toBeVisible({ timeout });
    });
  }
  async safeClick(selector: string): Promise<void> {
    await this.retry(async () => {
      const element = this.page.locator(selector);
      await element.waitFor({ state: 'visible', timeout: 10000 });
      await element.click({ timeout: 5000 });
    });
  }
  async safeFill(selector: string, value: string): Promise<void> {
    await this.retry(async () => {
      const element = this.page.locator(selector);
      await element.waitFor({ state: 'visible', timeout: 10000 });
      await element.clear();
      await element.fill(value);
    });
  }
  async safeSelect(selector: string, value: string): Promise<void> {
    await this.retry(async () => {
      const element = this.page.locator(selector);
      await element.waitFor({ state: 'visible', timeout: 10000 });
      await element.selectOption(value);
    });
  }
  async waitForURL(urlPattern: RegExp | string, timeout: number = 30000): Promise<void> {
    await this.retry(async () => {
      await this.page.waitForURL(urlPattern, { timeout });
    });
  }
  async handleModal(): Promise<void> {
    try {
      const modal = this.page.locator('.el-dialog, .el-message-box');
      const isVisible = await modal.isVisible({ timeout: 2000 });
      if (isVisible) {
        const confirmButton = modal.locator('.el-button--primary').first();
        const cancelButton = modal.locator('.el-button--default').first();
        if (await confirmButton.isVisible({ timeout: 1000 })) {
          await confirmButton.click();
        } else if (await cancelButton.isVisible({ timeout: 1000 })) {
          await cancelButton.click();
        }
      }
    } catch (error) {
      console.log('No modal found or modal handling failed');
    }
  }
  async waitForLoadingComplete(): Promise<void> {
    try {
      const loading = this.page.locator('.el-loading-mask, .loading');
      await loading.waitFor({ state: 'hidden', timeout: 10000 });
    } catch (error) {
      console.log('Loading element not found or timeout');
    }
  }
  async safeNavigate(url: string): Promise<void> {
    await this.retry(async () => {
      await this.page.goto(url, { waitUntil: 'networkidle', timeout: 30000 });
    });
  }
  async waitForTableData(tableSelector: string, minRows: number = 1): Promise<void> {
    await this.retry(async () => {
      const table = this.page.locator(tableSelector);
      await expect(table).toBeVisible({ timeout: 10000 });
      const rows = table.locator('.el-table__row');
      const rowCount = await rows.count();
      expect(rowCount).toBeGreaterThanOrEqual(minRows);
    });
  }
  async safeScrollIntoView(selector: string): Promise<void> {
    const element = this.page.locator(selector);
    await element.scrollIntoViewIfNeeded();
    await this.page.waitForTimeout(500);
  }
  async clearLocalStorage(): Promise<void> {
    await this.page.evaluate(() => {
      localStorage.clear();
    });
  }
  async clearSessionStorage(): Promise<void> {
    await this.page.evaluate(() => {
      sessionStorage.clear();
    });
  }
  async takeScreenshot(name: string): Promise<void> {
    await this.page.screenshot({ path: `test-results/screenshots/${name}.png`, fullPage: true });
  }
  async getErrorMessage(): Promise<string | null> {
    try {
      const errorElement = this.page.locator('.el-message--error, .error-message');
      const isVisible = await errorElement.isVisible({ timeout: 2000 });
      if (isVisible) {
        return await errorElement.textContent();
      }
      return null;
    } catch (error) {
      return null;
    }
  }
  async hasErrorMessage(): Promise<boolean> {
    const errorMessage = await this.getErrorMessage();
    return errorMessage !== null;
  }
  private async retry<T>(fn: () => Promise<T>): Promise<T> {
    let lastError: Error | undefined;
    for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
      try {
        return await fn();
      } catch (error) {
        lastError = error as Error;
        console.log(`Attempt ${attempt} failed, retrying...`, error);
        if (attempt < this.maxRetries) {
          await this.page.waitForTimeout(this.retryDelay);
        }
      }
    }
    throw lastError || new Error('All retry attempts failed');
  }
  async waitForElementNotVisible(selector: string, timeout: number = 10000): Promise<void> {
    await this.retry(async () => {
      const element = this.page.locator(selector);
      await expect(element).not.toBeVisible({ timeout });
    });
  }
  async safeHover(selector: string): Promise<void> {
    await this.retry(async () => {
      const element = this.page.locator(selector);
      await element.waitFor({ state: 'visible', timeout: 10000 });
      await element.hover({ timeout: 5000 });
    });
  }
  async waitForText(selector: string, text: string, timeout: number = 10000): Promise<void> {
    await this.retry(async () => {
      const element = this.page.locator(selector);
      await expect(element).toContainText(text, { timeout });
    });
  }
  async waitForTextNotPresent(selector: string, text: string, timeout: number = 10000): Promise<void> {
    await this.retry(async () => {
      const element = this.page.locator(selector);
      await expect(element).not.toContainText(text, { timeout });
    });
  }
 }
@@ -1,23 +0,0 @@
 import { Page } from '@playwright/test';
 export async function loginAsAdmin(page: Page) {
  await page.goto('/login');
  await page.waitForLoadState('networkidle');
  await page.locator('input[placeholder*="用户名"]').fill('admin');
  await page.locator('input[placeholder*="密码"]').fill('Test@123');
  await page.locator('button:has-text("登录")').click();
  await page.waitForURL('**/dashboard', { timeout: 30000 });
  const token = await page.evaluate(() => {
    return localStorage.getItem('token') || '';
  });
  return token;
 }
 export async function saveAuthState(page: Page) {
  const storage = await page.context().storageState();
  return storage;
 }
@@ -1,292 +0,0 @@
 import { test, expect } from '@playwright/test';
 test.describe('管理员完整工作流', () => {
  test.use({ storageState: 'playwright/.auth/user.json' });
  test.describe.configure({ mode: 'serial' });
  const timestamp = Date.now();
  const roleName = `测试角色_${timestamp}`;
  const roleKey = `test_role_${timestamp}`;
  const username = `testuser_${timestamp}`;
  test('创建角色并分配权限', async ({ page }) => {
    await test.step('导航到角色管理', async () => {
      await page.goto('/dashboard');
      await page.waitForLoadState('domcontentloaded');
      await page.waitForTimeout(1000);
      const token = await page.evaluate(() => localStorage.getItem('token'));
      console.log('Token in journey test:', token ? 'exists' : 'missing');
      const permission = await page.evaluate(() => localStorage.getItem('permission'));
      console.log('Permission in journey test:', permission ? 'exists' : 'missing');
      if (permission) {
        const permData = JSON.parse(permission);
        console.log('Has system:role:add:', permData.permissions?.includes('system:role:add'));
      }
      await page.waitForTimeout(2000);
      await page.waitForSelector('text=系统管理', { state: 'visible', timeout: 10000 });
      await page.locator('text=系统管理').click();
      await page.waitForTimeout(500);
      await page.waitForSelector('text=角色管理', { state: 'visible', timeout: 5000 });
      await page.locator('text=角色管理').click();
      await page.waitForLoadState('networkidle');
      await expect(page).toHaveURL(/.*roles/, { timeout: 10000 });
    });
    await test.step('点击创建角色按钮', async () => {
      await page.locator('button:has-text("新增角色")').click();
      await page.waitForSelector('.el-dialog', { state: 'visible', timeout: 5000 });
    });
    await test.step('填写角色信息', async () => {
      const dialog = page.locator('.el-dialog');
      await dialog.locator('input').first().fill(roleName);
      await dialog.locator('input').nth(1).fill(roleKey);
      await dialog.locator('.el-input-number .el-input__inner').fill('99');
    });
    await test.step('提交表单', async () => {
      const [response] = await Promise.all([
        page.waitForResponse(resp => 
          resp.url().includes('/api/roles') && resp.request().method() === 'POST',
          { timeout: 10000 }
        ).catch(() => null),
        page.locator('.el-dialog button:has-text("确定")').click()
      ]);
      if (response) {
        console.log('Response status:', response.status());
        console.log('Response URL:', response.url());
      } else {
        console.log('No response received - request may have been blocked by frontend');
      }
      await page.waitForSelector('.el-dialog', { state: 'hidden', timeout: 10000 });
      if (response && response.ok()) {
        await expect(page.locator('.el-message--success')).toBeVisible({ timeout: 5000 });
      } else {
        const errorMsg = await page.locator('.el-message--error').textContent().catch(() => 'Unknown error');
        console.log('Error message:', errorMsg);
        throw new Error(`创建角色失败: ${errorMsg}`);
      }
    });
  });
  test('创建用户并分配角色', async ({ page }) => {
    await test.step('导航到用户管理', async () => {
      await page.goto('/dashboard');
      await page.waitForLoadState('networkidle');
      await page.waitForSelector('text=系统管理', { state: 'visible', timeout: 10000 });
      await page.locator('text=系统管理').click();
      await page.waitForTimeout(500);
      await page.waitForSelector('text=用户管理', { state: 'visible', timeout: 5000 });
      await page.locator('text=用户管理').click();
      await page.waitForLoadState('networkidle');
      await expect(page).toHaveURL(/.*users/, { timeout: 10000 });
    });
    await test.step('点击创建用户按钮', async () => {
      await page.locator('button:has-text("新增用户")').click();
      await page.waitForSelector('.el-dialog', { state: 'visible', timeout: 5000 });
    });
    await test.step('填写用户信息', async () => {
      const dialog = page.locator('.el-dialog');
      await dialog.locator('input').first().fill(username);
      await dialog.locator('input[type="password"]').fill('Test@123');
      await dialog.locator('input').nth(2).fill(`测试用户${timestamp}`);
      await dialog.locator('input').nth(3).fill(`test_${timestamp}@example.com`);
      await dialog.locator('input').nth(4).fill('13800138000');
    });
    await test.step('提交表单', async () => {
      await page.locator('.el-dialog button:has-text("确定")').click();
      await page.waitForSelector('.el-dialog', { state: 'hidden', timeout: 10000 });
      await expect(page.locator('.el-message--success')).toBeVisible({ timeout: 5000 });
    });
    await test.step('搜索新创建的用户', async () => {
      await page.waitForTimeout(1000);
      const searchInput = page.locator('input[placeholder*="搜索"]');
      await searchInput.waitFor({ state: 'visible', timeout: 5000 });
      await searchInput.fill(username);
      await page.locator('button:has-text("搜索")').click();
      await page.waitForLoadState('networkidle');
      await page.waitForTimeout(2000);
    });
    await test.step('分配角色', async () => {
      const userRow = page.locator(`tr:has-text("${username}")`);
      await expect(userRow).toBeVisible({ timeout: 10000 });
      const userIdText = await userRow.locator('td').first().textContent();
      const userId = userIdText?.trim();
      await userRow.locator('button:has-text("分配角色")').click();
      await page.waitForSelector('.el-dialog:has-text("分配角色")', { state: 'visible', timeout: 5000 });
      const transfer = page.locator('.el-transfer');
      const leftPanel = transfer.locator('.el-transfer-panel').first();
      const rightPanel = transfer.locator('.el-transfer-panel').last();
      const rightPanelItems = await rightPanel.locator('.el-checkbox').all();
      let hasSuperAdminRole = false;
      for (const item of rightPanelItems) {
        const text = await item.textContent();
        if (text?.includes('超级管理员')) {
          hasSuperAdminRole = true;
          break;
        }
      }
      if (!hasSuperAdminRole) {
        const leftPanelCheckboxes = leftPanel.locator('.el-transfer-panel__body .el-checkbox');
        const leftCount = await leftPanelCheckboxes.count();
        for (let i = 0; i < leftCount; i++) {
          const checkbox = leftPanelCheckboxes.nth(i);
          const text = await checkbox.textContent();
          if (text?.includes('超级管理员')) {
            await checkbox.locator('.el-checkbox__input').click();
            await page.waitForTimeout(500);
            break;
          }
        }
        const moveToRightBtn = transfer.locator('.el-transfer__buttons button').nth(1);
        await moveToRightBtn.waitFor({ state: 'visible', timeout: 3000 });
        if (await moveToRightBtn.isEnabled()) {
          await moveToRightBtn.click();
          await page.waitForTimeout(1000);
        }
      }
      const confirmBtn = page.locator('.el-dialog:has-text("分配角色") button:has-text("确定")');
      await confirmBtn.click();
      const dialogHidden = await page.waitForSelector('.el-dialog:has-text("分配角色")', { state: 'hidden', timeout: 10000 })
        .then(() => true)
        .catch(() => false);
      if (!dialogHidden) {
        const token = await page.evaluate(() => localStorage.getItem('token'));
        if (userId && token) {
          const assignResponse = await page.evaluate(async ({ uid, tk }) => {
            try {
              const timestamp = Date.now().toString();
              const nonce = timestamp + '-' + Math.random().toString(36).substring(2, 15);
              const method = 'POST';
              const path = `/api/users/${uid}/roles`;
              const body = JSON.stringify({ roleIds: ['1'] });
              const stringToSign = [method, path, '', '', timestamp, nonce].join('\n');
              const encoder = new TextEncoder();
              const keyData = encoder.encode('NovalonManageSystemSecretKey2026');
              const key = await crypto.subtle.importKey('raw', keyData, { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
              const signatureData = encoder.encode(stringToSign);
              const signatureBuffer = await crypto.subtle.sign('HMAC', key, signatureData);
              const signatureArray = Array.from(new Uint8Array(signatureBuffer));
              const signatureBase64 = btoa(String.fromCharCode(...signatureArray));
              const res = await fetch(path, {
                method: method,
                headers: {
                  'Content-Type': 'application/json',
                  'Authorization': `Bearer ${tk}`,
                  'X-Signature': signatureBase64,
                  'X-Timestamp': timestamp,
                  'X-Nonce': nonce
                },
                body: body
              });
              return { ok: res.ok, status: res.status };
            } catch (e) {
              return { ok: false, error: String(e) };
            }
          }, { uid: userId, tk: token });
          if (assignResponse.ok) {
            const cancelBtn = page.locator('.el-dialog:has-text("分配角色") button:has-text("取消")');
            if (await cancelBtn.isVisible()) {
              await cancelBtn.click();
            }
          }
        }
      }
      await page.waitForTimeout(1000);
    });
  });
  test('验证新用户登录', async ({ page }) => {
    await test.step('管理员登出', async () => {
      await page.goto('/dashboard');
      await page.waitForLoadState('domcontentloaded');
      await page.waitForTimeout(1000);
      const avatarButton = page.locator('.el-avatar').first();
      await avatarButton.click({ timeout: 10000 });
      await page.waitForTimeout(500);
      await page.locator('text=退出登录').click();
      await page.waitForURL(/.*login/, { timeout: 10000 });
    });
    await test.step('新用户登录', async () => {
      await page.goto('/login');
      await page.locator('input[placeholder*="用户名"]').fill(username);
      await page.locator('input[placeholder*="密码"]').fill('Test@123');
      await page.locator('button:has-text("登录")').click();
      await page.waitForURL('**/dashboard', { timeout: 30000 });
    });
    await test.step('验证用户已登录', async () => {
      await expect(page).toHaveURL(/.*dashboard/);
    });
  });
  test.skip('清理测试数据', async ({ page }) => {
    await test.step('管理员重新登录', async () => {
      await page.goto('/dashboard');
      await page.waitForLoadState('networkidle');
      const avatarButton = page.locator('.el-avatar').first();
      if (await avatarButton.isVisible()) {
        await avatarButton.click();
        await page.waitForTimeout(500);
        await page.locator('text=退出登录').click();
      }
      await page.goto('/login');
      await page.locator('input[placeholder*="用户名"]').fill('admin');
      await page.locator('input[placeholder*="密码"]').fill('Test@123');
      await page.locator('button:has-text("登录")').click();
      await page.waitForURL('**/dashboard');
    });
    await test.step('删除测试用户', async () => {
      await page.goto('/users');
      await page.locator('input[placeholder*="搜索"]').fill(username);
      await page.locator('button:has-text("搜索")').click();
      await page.waitForTimeout(1000);
      await page.locator('button:has-text("删除")').first().click();
      await page.locator('button:has-text("确定")').click();
      await expect(page.locator('.el-message--success')).toBeVisible({ timeout: 5000 });
    });
    await test.step('删除测试角色', async () => {
      await page.goto('/roles');
      await page.locator('input[placeholder*="搜索"]').fill(roleName);
      await page.locator('button:has-text("搜索")').click();
      await page.waitForTimeout(1000);
      await page.locator('button:has-text("删除")').first().click();
      await page.locator('button:has-text("确定")').click();
      await expect(page.locator('.el-message--success')).toBeVisible({ timeout: 5000 });
    });
  });
 });
@@ -1,130 +0,0 @@
 import { test, expect } from '@playwright/test';
 test.describe('审计工作流', () => {
  test('执行操作并查看操作日志', async ({ page }) => {
    await test.step('执行产生操作日志的写操作', async () => {
      await page.goto('/roles');
      await page.waitForLoadState('networkidle');
      await page.waitForTimeout(1000);
      const createBtn = page.locator('button:has-text("新增角色")');
      await createBtn.waitFor({ state: 'visible', timeout: 5000 });
      await createBtn.click();
      await page.waitForSelector('.el-dialog', { state: 'visible', timeout: 5000 });
      const dialog = page.locator('.el-dialog');
      const timestamp = Date.now();
      await dialog.locator('input').first().fill(`审计测试角色_${timestamp}`);
      await dialog.locator('input').nth(1).fill(`audit_test_${timestamp}`);
      await dialog.locator('.el-input-number .el-input__inner').fill('99');
      await page.locator('.el-dialog button:has-text("确定")').click();
      await page.waitForSelector('.el-dialog', { state: 'hidden', timeout: 10000 }).catch(() => {});
      await page.waitForTimeout(2000);
    });
    await test.step('导航到操作日志', async () => {
      await page.goto('/dashboard');
      await page.waitForLoadState('domcontentloaded');
      await page.waitForTimeout(1000);
      await page.locator('text=审计日志').waitFor({ state: 'visible', timeout: 5000 });
      await page.locator('text=审计日志').click();
      await page.waitForTimeout(1000);
      await page.locator('.el-menu-item:has-text("操作日志")').waitFor({ state: 'visible', timeout: 5000 });
      await page.locator('.el-menu-item:has-text("操作日志")').click();
      await page.waitForLoadState('domcontentloaded');
      await page.waitForTimeout(2000);
      await expect(page).toHaveURL(/.*oplog/, { timeout: 10000 });
      await expect(page.locator('.el-table')).toBeVisible({ timeout: 10000 });
    });
    await test.step('验证操作日志记录', async () => {
      await page.waitForTimeout(2000);
      const logContent = await page.locator('.el-table').textContent();
      const hasLog = logContent && !logContent.includes('暂无数据');
      if (hasLog) {
        expect(logContent).toMatch(/角色管理|用户管理|菜单管理/);
      } else {
        await page.reload();
        await page.waitForLoadState('domcontentloaded');
        await page.waitForTimeout(3000);
        const refreshedContent = await page.locator('.el-table').textContent();
        expect(refreshedContent).toMatch(/角色管理|用户管理|菜单管理/);
      }
    });
  });
  test('查看登录日志', async ({ page }) => {
    await test.step('导航到登录日志', async () => {
      await page.goto('/dashboard');
      await page.waitForLoadState('domcontentloaded');
      await page.waitForTimeout(1000);
      await page.locator('text=审计日志').waitFor({ state: 'visible', timeout: 5000 });
      await page.locator('text=审计日志').click();
      await page.waitForTimeout(1000);
      await page.locator('.el-menu-item:has-text("登录日志")').waitFor({ state: 'visible', timeout: 5000 });
      await page.locator('.el-menu-item:has-text("登录日志")').click();
      await page.waitForLoadState('domcontentloaded');
      await page.waitForTimeout(1000);
      await expect(page).toHaveURL(/.*loginlog/, { timeout: 15000 });
    });
    await test.step('验证登录日志显示', async () => {
      await expect(page.locator('.el-table')).toBeVisible({ timeout: 10000 });
      const logContent = await page.locator('.el-table').textContent();
      expect(logContent).toBeTruthy();
      expect(logContent.length).toBeGreaterThan(0);
    });
  });
  test('搜索和筛选日志', async ({ page }) => {
    await test.step('导航到操作日志', async () => {
      await page.goto('/dashboard');
      await page.waitForLoadState('domcontentloaded');
      await page.waitForTimeout(1000);
      await page.locator('text=审计日志').waitFor({ state: 'visible', timeout: 5000 });
      await page.locator('text=审计日志').click();
      await page.waitForTimeout(1000);
      await page.locator('.el-menu-item:has-text("操作日志")').waitFor({ state: 'visible', timeout: 5000 });
      await page.locator('.el-menu-item:has-text("操作日志")').click();
      await page.waitForLoadState('domcontentloaded');
      await page.waitForTimeout(1000);
      await expect(page.locator('.el-table')).toBeVisible({ timeout: 10000 });
    });
    await test.step('按模块筛选', async () => {
      const moduleSelect = page.locator('.el-select:has-text("模块")');
      if (await moduleSelect.isVisible()) {
        await moduleSelect.click();
        await page.locator('.el-select-dropdown__item:has-text("用户管理")').click();
        await page.waitForTimeout(1000);
      }
    });
    await test.step('按时间范围筛选', async () => {
      const dateRangePicker = page.locator('.el-date-editor');
      if (await dateRangePicker.isVisible()) {
        await dateRangePicker.click();
        await page.waitForTimeout(500);
      }
    });
    await test.step('搜索特定内容', async () => {
      const searchInput = page.locator('input[placeholder*="搜索"]');
      if (await searchInput.isVisible()) {
        await searchInput.fill('admin');
        await page.locator('button:has-text("搜索")').click();
        await page.waitForTimeout(1000);
      }
    });
  });
 });
@@ -1,140 +0,0 @@
 import { test, expect } from '@playwright/test';
 import { SystemConfigPage } from '../pages/SystemConfigPage';
 test.describe('系统配置工作流', () => {
  let configPage: SystemConfigPage;
  const timestamp = Date.now();
  const configKey = `test_config_${timestamp}`;
  const configName = `测试配置_${timestamp}`;
  const configValue = `测试值_${timestamp}`;
  test.beforeEach(async ({ page }) => {
    configPage = new SystemConfigPage(page);
  });
  test('查看系统配置列表', async ({ page }) => {
    await test.step('导航到系统配置页面', async () => {
      await configPage.goto();
    });
    await test.step('验证表格显示', async () => {
      await expect(configPage.table).toBeVisible({ timeout: 10000 });
    });
    await test.step('验证数据加载', async () => {
      const rowCount = await configPage.getTableRowCount();
      console.log(`系统配置列表包含 ${rowCount} 条记录`);
      expect(rowCount).toBeGreaterThanOrEqual(0);
    });
  });
  test('新增系统配置', async ({ page }) => {
    await test.step('导航到系统配置页面', async () => {
      await configPage.goto();
    });
    await test.step('点击新增配置按钮', async () => {
      await configPage.addButton.click();
      await configPage.dialog.waitFor({ state: 'visible', timeout: 5000 });
    });
    await test.step('填写配置表单', async () => {
      await configPage.configNameInput.fill(configName);
      await configPage.configKeyInput.fill(configKey);
      await configPage.configValueInput.fill(configValue);
    });
    await test.step('提交表单', async () => {
      await configPage.saveButton.click();
      await page.waitForLoadState('networkidle');
    });
    await test.step('验证创建成功', async () => {
      await expect(configPage.dialog).not.toBeVisible({ timeout: 5000 });
      console.log(`配置 ${configName} 创建完成`);
    });
  });
  test('编辑系统配置', async ({ page }) => {
    await test.step('导航到系统配置页面', async () => {
      await configPage.goto();
    });
    await test.step('等待数据加载', async () => {
      await expect(configPage.table).toBeVisible({ timeout: 10000 });
    });
    await test.step('点击编辑按钮', async () => {
      const rows = await configPage.getTableRowCount();
      if (rows > 0) {
        const firstRow = configPage.table.locator('tr').first();
        const editBtn = firstRow.getByRole('button', { name: '编辑' });
        if (await editBtn.isVisible({ timeout: 3000 }).catch(() => false)) {
          await editBtn.click();
          await configPage.dialog.waitFor({ state: 'visible', timeout: 5000 });
          await test.step('修改配置值', async () => {
            const newValue = `更新值_${timestamp}`;
            await configPage.configValueInput.clear();
            await configPage.configValueInput.fill(newValue);
          });
          await test.step('提交表单', async () => {
            await configPage.saveButton.click();
            await page.waitForLoadState('networkidle');
          });
          await test.step('验证更新成功', async () => {
            await expect(configPage.dialog).not.toBeVisible({ timeout: 5000 });
            console.log(`配置已更新`);
          });
        } else {
          console.log('未找到编辑按钮，跳过编辑测试');
        }
      } else {
        console.log('当前没有配置记录，跳过编辑测试');
      }
    });
  });
  test('删除系统配置', async ({ page }) => {
    await test.step('导航到系统配置页面', async () => {
      await configPage.goto();
    });
    await test.step('等待数据加载', async () => {
      await expect(configPage.table).toBeVisible({ timeout: 10000 });
    });
    await test.step('点击删除按钮', async () => {
      const rows = await configPage.getTableRowCount();
      if (rows > 0) {
        const firstRow = configPage.table.locator('tr').first();
        const deleteBtn = firstRow.getByRole('button', { name: '删除' });
        if (await deleteBtn.isVisible({ timeout: 3000 }).catch(() => false)) {
          await deleteBtn.click();
          const confirmBtn = page.locator('.el-message-box');
          await confirmBtn.waitFor({ state: 'visible', timeout: 3000 });
          await test.step('确认删除', async () => {
            const confirmBtn = page.locator('.el-message-box').getByRole('button', { name: '确定' });
            if (await confirmBtn.isVisible({ timeout: 2000 }).catch(() => false)) {
              await confirmBtn.click();
              await page.waitForLoadState('networkidle');
            }
          });
          await test.step('验证删除成功', async () => {
            const messageBox = page.locator('.el-message-box');
            await expect(messageBox).not.toBeVisible({ timeout: 5000 });
            console.log(`配置已删除`);
          });
        } else {
          console.log('未找到删除按钮，跳过删除测试');
        }
      } else {
        console.log('当前没有配置记录，跳过删除测试');
      }
    });
  });
 });
@@ -1,138 +0,0 @@
 import { test, expect } from '@playwright/test';
 import { DictionaryManagementPage } from '../pages/DictionaryManagementPage';
 test.describe('字典管理工作流', () => {
  let dictPage: DictionaryManagementPage;
  const timestamp = Date.now();
  const dictType = `test_dict_${timestamp}`;
  const dictName = `测试字典_${timestamp}`;
  test.beforeEach(async ({ page }) => {
    dictPage = new DictionaryManagementPage(page);
  });
  test('查看字典列表', async ({ page }) => {
    await test.step('导航到字典管理页面', async () => {
      await dictPage.goto();
    });
    await test.step('验证表格显示', async () => {
      await expect(dictPage.table).toBeVisible({ timeout: 10000 });
    });
    await test.step('验证数据加载', async () => {
      const rowCount = await dictPage.getDictCount();
      console.log(`字典列表包含 ${rowCount} 条记录`);
      expect(rowCount).toBeGreaterThanOrEqual(0);
    });
  });
  test('新增字典', async ({ page }) => {
    await test.step('导航到字典管理页面', async () => {
      await dictPage.goto();
    });
    await test.step('点击新增字典按钮', async () => {
      await dictPage.createDictButton.click();
      await dictPage.dialog.waitFor({ state: 'visible', timeout: 5000 });
    });
    await test.step('填写字典表单', async () => {
      await dictPage.dictNameInput.fill(dictName);
      await dictPage.dictTypeInput.fill(dictType);
    });
    await test.step('提交表单', async () => {
      await dictPage.saveButton.click();
      await page.waitForLoadState('networkidle');
    });
    await test.step('验证创建成功', async () => {
      await expect(dictPage.dialog).not.toBeVisible({ timeout: 5000 });
      console.log(`字典 ${dictName} 创建完成`);
    });
  });
  test('编辑字典', async ({ page }) => {
    await test.step('导航到字典管理页面', async () => {
      await dictPage.goto();
    });
    await test.step('等待数据加载', async () => {
      await expect(dictPage.table).toBeVisible({ timeout: 10000 });
    });
    await test.step('点击编辑按钮', async () => {
      const rows = await dictPage.getDictCount();
      if (rows > 0) {
        const firstRow = dictPage.table.locator('tr').first();
        const editBtn = firstRow.getByRole('button', { name: '编辑' });
        if (await editBtn.isVisible({ timeout: 3000 }).catch(() => false)) {
          await editBtn.click();
          await dictPage.dialog.waitFor({ state: 'visible', timeout: 5000 });
          await test.step('修改字典名称', async () => {
            const newName = `更新字典_${timestamp}`;
            await dictPage.dictNameInput.clear();
            await dictPage.dictNameInput.fill(newName);
          });
          await test.step('提交表单', async () => {
            await dictPage.saveButton.click();
            await page.waitForLoadState('networkidle');
          });
          await test.step('验证更新成功', async () => {
            await expect(dictPage.dialog).not.toBeVisible({ timeout: 5000 });
            console.log(`字典已更新`);
          });
        } else {
          console.log('未找到编辑按钮，跳过编辑测试');
        }
      } else {
        console.log('当前没有字典记录，跳过编辑测试');
      }
    });
  });
  test('删除字典', async ({ page }) => {
    await test.step('导航到字典管理页面', async () => {
      await dictPage.goto();
    });
    await test.step('等待数据加载', async () => {
      await expect(dictPage.table).toBeVisible({ timeout: 10000 });
    });
    await test.step('点击删除按钮', async () => {
      const rows = await dictPage.getDictCount();
      if (rows > 0) {
        const firstRow = dictPage.table.locator('tr').first();
        const deleteBtn = firstRow.getByRole('button', { name: '删除' });
        if (await deleteBtn.isVisible({ timeout: 3000 }).catch(() => false)) {
          await deleteBtn.click();
          const confirmBtn = page.locator('.el-message-box');
          await confirmBtn.waitFor({ state: 'visible', timeout: 3000 });
          await test.step('确认删除', async () => {
            const confirmBtn = page.locator('.el-message-box').getByRole('button', { name: '确定' });
            if (await confirmBtn.isVisible({ timeout: 2000 }).catch(() => false)) {
              await confirmBtn.click();
              await page.waitForLoadState('networkidle');
            }
          });
          await test.step('验证删除成功', async () => {
            const messageBox = page.locator('.el-message-box');
            await expect(messageBox).not.toBeVisible({ timeout: 5000 });
            console.log(`字典已删除`);
          });
        } else {
          console.log('未找到删除按钮，跳过删除测试');
        }
      } else {
        console.log('当前没有字典记录，跳过删除测试');
      }
    });
  });
 });
@@ -1,124 +0,0 @@
 import { test, expect } from '@playwright/test';
 test.describe('字典管理完整工作流', () => {
  test.describe.configure({ mode: 'serial' });
  const timestamp = Date.now();
  const dictName = `测试字典_${timestamp}`;
  const dictType = `test_dict_${timestamp}`;
  test('创建字典', async ({ page }) => {
    await test.step('导航到字典管理', async () => {
      await page.goto('/dashboard');
      await page.waitForLoadState('domcontentloaded');
      await page.waitForTimeout(1000);
      await page.locator('text=系统管理').waitFor({ state: 'visible', timeout: 5000 });
      await page.locator('text=系统管理').click();
      await page.waitForTimeout(500);
      await page.locator('text=字典管理').waitFor({ state: 'visible', timeout: 5000 });
      await page.locator('text=字典管理').click();
      await page.waitForLoadState('domcontentloaded');
      await expect(page).toHaveURL(/.*dict/, { timeout: 15000 });
    });
    await test.step('点击新增字典按钮', async () => {
      await page.locator('button:has-text("新增字典")').click();
      await page.waitForSelector('.el-dialog', { state: 'visible', timeout: 5000 });
    });
    await test.step('填写字典信息', async () => {
      const dialog = page.locator('.el-dialog');
      await dialog.locator('input').first().fill(dictName);
      await dialog.locator('input').nth(1).fill(dictType);
    });
    await test.step('提交表单', async () => {
      await page.locator('.el-dialog button:has-text("确定")').click();
      await page.waitForSelector('.el-dialog', { state: 'hidden', timeout: 10000 });
      await expect(page.locator('.el-message--success')).toBeVisible({ timeout: 5000 });
    });
    await test.step('验证字典已创建', async () => {
      await page.waitForTimeout(2000);
      const dictRow = page.locator(`tr:has-text("${dictName}")`);
      await expect(dictRow).toBeVisible({ timeout: 15000 });
    });
  });
  test('编辑字典', async ({ page }) => {
    const updatedName = `更新字典_${timestamp}`;
    await test.step('导航到字典管理', async () => {
      await page.goto('/dashboard');
      await page.waitForLoadState('networkidle');
      await page.locator('text=系统管理').click();
      await page.waitForTimeout(500);
      await page.locator('text=字典管理').waitFor({ state: 'visible', timeout: 5000 });
      await page.locator('text=字典管理').click();
      await page.waitForLoadState('networkidle');
      await expect(page).toHaveURL(/.*dict/, { timeout: 10000 });
    });
    await test.step('搜索并编辑字典', async () => {
      const dictRow = page.locator(`tr:has-text("${dictName}")`);
      await dictRow.locator('button:has-text("编辑")').click();
      await page.waitForSelector('.el-dialog', { state: 'visible', timeout: 5000 });
    });
    await test.step('修改字典信息', async () => {
      const dialog = page.locator('.el-dialog');
      await dialog.locator('input').first().fill(updatedName);
    });
    await test.step('提交更新', async () => {
      await page.locator('.el-dialog button:has-text("确定")').click();
      await page.waitForSelector('.el-dialog', { state: 'hidden', timeout: 10000 });
      await expect(page.locator('.el-message--success')).toBeVisible({ timeout: 5000 });
    });
    await test.step('验证字典已更新', async () => {
      await page.waitForTimeout(2000);
      const dictRow = page.locator(`tr:has-text("${updatedName}")`);
      await expect(dictRow).toBeVisible({ timeout: 15000 });
    });
  });
  test('删除字典', async ({ page }) => {
    await test.step('导航到字典管理', async () => {
      await page.goto('/dashboard');
      await page.waitForLoadState('networkidle');
      await page.locator('text=系统管理').click();
      await page.waitForTimeout(500);
      await page.locator('text=字典管理').click();
      await page.waitForLoadState('networkidle');
    });
    await test.step('搜索并删除字典', async () => {
      const dictRow = page.locator(`tr:has-text("更新字典_${timestamp}")`);
      await dictRow.locator('button:has-text("删除")').click();
      await page.waitForSelector('.el-message-box', { state: 'visible', timeout: 5000 });
    });
    await test.step('确认删除', async () => {
      await page.locator('.el-message-box button:has-text("确定")').click();
      await page.waitForSelector('.el-message-box', { state: 'hidden', timeout: 10000 });
      await expect(page.locator('.el-message--success')).toBeVisible({ timeout: 5000 });
    });
    await test.step('验证字典已删除', async () => {
      await page.waitForTimeout(1000);
      const dictRow = page.locator(`tr:has-text("更新字典_${timestamp}")`);
      await expect(dictRow).not.toBeVisible({ timeout: 5000 });
    });
  });
  test('字典管理功能验证', async ({ page }) => {
    await test.step('验证字典管理页面访问权限', async () => {
      await page.goto('/dict');
      await page.waitForLoadState('networkidle');
      await expect(page.locator('.el-card')).toBeVisible({ timeout: 5000 });
      await expect(page.locator('button:has-text("新增字典")')).toBeVisible();
    });
  });
 });
@@ -1,73 +0,0 @@
 import { test, expect } from '@playwright/test';
 import { ExceptionLogPage } from '../pages/ExceptionLogPage';
 test.describe('异常日志工作流', () => {
  let exceptionLogPage: ExceptionLogPage;
  test.beforeEach(async ({ page }) => {
    exceptionLogPage = new ExceptionLogPage(page);
  });
  test('查看异常日志列表', async ({ page }) => {
    await test.step('导航到异常日志页面', async () => {
      await exceptionLogPage.goto();
    });
    await test.step('验证表格显示', async () => {
      await expect(exceptionLogPage.table).toBeVisible({ timeout: 10000 });
    });
    await test.step('验证数据加载', async () => {
      const rowCount = await exceptionLogPage.getLogCount();
      console.log(`异常日志列表包含 ${rowCount} 条记录`);
      expect(rowCount).toBeGreaterThanOrEqual(0);
    });
  });
  test('搜索异常日志', async ({ page }) => {
    await test.step('导航到异常日志页面', async () => {
      await exceptionLogPage.goto();
    });
    await test.step('输入搜索关键词', async () => {
      const searchKeyword = 'NullPointerException';
      await exceptionLogPage.search(searchKeyword);
    });
    await test.step('验证搜索结果', async () => {
      await page.waitForLoadState('domcontentloaded');
      await page.waitForTimeout(1000);
      const rowCount = await exceptionLogPage.getLogCount();
      console.log(`搜索结果包含 ${rowCount} 条记录`);
    });
  });
  test('查看异常日志详情', async ({ page }) => {
    await test.step('导航到异常日志页面', async () => {
      await exceptionLogPage.goto();
    });
    await test.step('等待数据加载', async () => {
      await expect(exceptionLogPage.table).toBeVisible({ timeout: 10000 });
    });
    await test.step('点击查看详情按钮', async () => {
      const detailButton = page.locator('button:has-text("详情")').or(page.locator('.detail-button')).first();
      if (await detailButton.isVisible({ timeout: 3000 }).catch(() => false)) {
        await detailButton.click();
        await test.step('验证详情对话框显示', async () => {
          const dialog = page.locator('.el-dialog');
          await expect(dialog).toBeVisible({ timeout: 5000 });
          console.log('异常日志详情对话框已打开');
        });
        await test.step('关闭详情对话框', async () => {
          await exceptionLogPage.closeDetailDialog();
        });
      } else {
        console.log('当前没有异常日志记录，跳过详情查看测试');
      }
    });
  });
 });
@@ -1,91 +0,0 @@
 import { test, expect } from '@playwright/test';
 test.describe('文件管理工作流', () => {
  test('文件上传流程', async ({ page }) => {
    await test.step('导航到文件管理', async () => {
      await page.goto('/dashboard');
      await page.waitForLoadState('domcontentloaded');
      await page.waitForTimeout(1000);
      await page.locator('text=系统管理').waitFor({ state: 'visible', timeout: 5000 });
      await page.locator('text=系统管理').click();
      await page.waitForTimeout(500);
      await page.locator('.el-menu-item:has-text("文件管理")').waitFor({ state: 'visible', timeout: 5000 });
      await page.locator('.el-menu-item:has-text("文件管理")').click();
      await page.waitForLoadState('domcontentloaded');
      await page.waitForTimeout(1000);
      await expect(page.locator('.el-table')).toBeVisible({ timeout: 10000 });
    });
    await test.step('上传文件', async () => {
      const uploadButton = page.locator('button:has-text("上传")');
      if (await uploadButton.isVisible()) {
        const fileInput = page.locator('input[type="file"]');
        await fileInput.setInputFiles({
          name: 'test-file.txt',
          mimeType: 'text/plain',
          buffer: Buffer.from('Test file content'),
        });
        await page.waitForTimeout(2000);
      }
    });
    await test.step('验证文件上传成功', async () => {
      const successMessage = page.locator('.el-message--success');
      if (await successMessage.isVisible()) {
        expect(await successMessage.textContent()).toContain('成功');
      }
    });
  });
  test('文件搜索和筛选', async ({ page }) => {
    await test.step('导航到文件管理', async () => {
      await page.goto('/dashboard');
      await page.locator('text=系统管理').click();
      await page.locator('text=文件管理').click();
    });
    await test.step('搜索文件', async () => {
      const searchInput = page.locator('input[placeholder*="搜索"]');
      if (await searchInput.isVisible()) {
        await searchInput.fill('test');
        await page.waitForTimeout(1000);
      }
    });
    await test.step('按类型筛选', async () => {
      const typeFilter = page.locator('.el-select:has-text("类型")');
      if (await typeFilter.isVisible()) {
        await typeFilter.click();
        await page.locator('.el-select-dropdown__item').first().click();
        await page.waitForTimeout(1000);
      }
    });
  });
  test('文件删除流程', async ({ page }) => {
    await test.step('导航到文件管理', async () => {
      await page.goto('/dashboard');
      await page.locator('text=系统管理').click();
      await page.locator('text=文件管理').click();
    });
    await test.step('选择文件', async () => {
      const fileCheckbox = page.locator('.el-checkbox').first();
      if (await fileCheckbox.isVisible()) {
        await fileCheckbox.click();
      }
    });
    await test.step('删除文件', async () => {
      const deleteButton = page.locator('button:has-text("删除")').first();
      if (await deleteButton.isVisible()) {
        await deleteButton.click();
        await page.locator('button:has-text("确定")').click();
        await page.waitForTimeout(1000);
      }
    });
  });
 });
@@ -1,138 +0,0 @@
 import { test, expect } from '@playwright/test';
 import { NotificationPage } from '../pages/NotificationPage';
 test.describe('通知管理工作流', () => {
  let noticePage: NotificationPage;
  const timestamp = Date.now();
  const noticeTitle = `测试通知_${timestamp}`;
  const noticeContent = `这是测试通知内容_${timestamp}`;
  test.beforeEach(async ({ page }) => {
    noticePage = new NotificationPage(page);
  });
  test('查看通知列表', async ({ page }) => {
    await test.step('导航到通知管理页面', async () => {
      await noticePage.goto();
    });
    await test.step('验证表格显示', async () => {
      await expect(noticePage.table).toBeVisible({ timeout: 10000 });
    });
    await test.step('验证数据加载', async () => {
      const rowCount = await noticePage.getTableRowCount();
      console.log(`通知列表包含 ${rowCount} 条记录`);
      expect(rowCount).toBeGreaterThanOrEqual(0);
    });
  });
  test('新增通知', async ({ page }) => {
    await test.step('导航到通知管理页面', async () => {
      await noticePage.goto();
    });
    await test.step('点击新增通知按钮', async () => {
      await noticePage.addButton.click();
      await noticePage.dialog.waitFor({ state: 'visible', timeout: 5000 });
    });
    await test.step('填写通知表单', async () => {
      await noticePage.titleInput.fill(noticeTitle);
      await noticePage.contentInput.fill(noticeContent);
    });
    await test.step('提交表单', async () => {
      await noticePage.saveButton.click();
      await page.waitForLoadState('networkidle');
    });
    await test.step('验证创建成功', async () => {
      await expect(noticePage.dialog).not.toBeVisible({ timeout: 5000 });
      console.log(`通知 ${noticeTitle} 创建完成`);
    });
  });
  test('编辑通知', async ({ page }) => {
    await test.step('导航到通知管理页面', async () => {
      await noticePage.goto();
    });
    await test.step('等待数据加载', async () => {
      await expect(noticePage.table).toBeVisible({ timeout: 10000 });
    });
    await test.step('点击编辑按钮', async () => {
      const rows = await noticePage.getTableRowCount();
      if (rows > 0) {
        const firstRow = noticePage.table.locator('tr').first();
        const editBtn = firstRow.getByRole('button', { name: '编辑' });
        if (await editBtn.isVisible({ timeout: 3000 }).catch(() => false)) {
          await editBtn.click();
          await noticePage.dialog.waitFor({ state: 'visible', timeout: 5000 });
          await test.step('修改通知内容', async () => {
            const newContent = `更新通知内容_${timestamp}`;
            await noticePage.contentInput.clear();
            await noticePage.contentInput.fill(newContent);
          });
          await test.step('提交表单', async () => {
            await noticePage.saveButton.click();
            await page.waitForLoadState('networkidle');
          });
          await test.step('验证更新成功', async () => {
            await expect(noticePage.dialog).not.toBeVisible({ timeout: 5000 });
            console.log(`通知已更新`);
          });
        } else {
          console.log('未找到编辑按钮，跳过编辑测试');
        }
      } else {
        console.log('当前没有通知记录，跳过编辑测试');
      }
    });
  });
  test('删除通知', async ({ page }) => {
    await test.step('导航到通知管理页面', async () => {
      await noticePage.goto();
    });
    await test.step('等待数据加载', async () => {
      await expect(noticePage.table).toBeVisible({ timeout: 10000 });
    });
    await test.step('点击删除按钮', async () => {
      const rows = await noticePage.getTableRowCount();
      if (rows > 0) {
        const firstRow = noticePage.table.locator('tr').first();
        const deleteBtn = firstRow.getByRole('button', { name: '删除' });
        if (await deleteBtn.isVisible({ timeout: 3000 }).catch(() => false)) {
          await deleteBtn.click();
          const confirmBtn = page.locator('.el-message-box');
          await confirmBtn.waitFor({ state: 'visible', timeout: 3000 });
          await test.step('确认删除', async () => {
            const confirmBtn = page.locator('.el-message-box').getByRole('button', { name: '确定' });
            if (await confirmBtn.isVisible({ timeout: 2000 }).catch(() => false)) {
              await confirmBtn.click();
              await page.waitForLoadState('networkidle');
            }
          });
          await test.step('验证删除成功', async () => {
            const messageBox = page.locator('.el-message-box');
            await expect(messageBox).not.toBeVisible({ timeout: 5000 });
            console.log(`通知已删除`);
          });
        } else {
          console.log('未找到删除按钮，跳过删除测试');
        }
      } else {
        console.log('当前没有通知记录，跳过删除测试');
      }
    });
  });
 });
@@ -1,124 +0,0 @@
 import { test, expect } from '@playwright/test';
 test.describe('参数管理完整工作流', () => {
  test.describe.configure({ mode: 'serial' });
  const timestamp = Date.now();
  const configName = `测试配置_${timestamp}`;
  const configKey = `test_config_${timestamp}`;
  const configValue = `test_value_${timestamp}`;
  test('创建参数配置', async ({ page }) => {
    await test.step('导航到参数管理', async () => {
      await page.goto('/dashboard');
      await page.waitForLoadState('domcontentloaded');
      await page.waitForTimeout(1000);
      await page.locator('text=系统管理').waitFor({ state: 'visible', timeout: 5000 });
      await page.locator('text=系统管理').click();
      await page.waitForTimeout(500);
      await page.locator('text=参数管理').waitFor({ state: 'visible', timeout: 5000 });
      await page.locator('text=参数管理').click();
      await page.waitForLoadState('domcontentloaded');
      await expect(page).toHaveURL(/.*config/, { timeout: 15000 });
    });
    await test.step('点击新增配置按钮', async () => {
      await page.locator('button:has-text("新增配置")').click();
      await page.waitForSelector('.el-dialog', { state: 'visible', timeout: 5000 });
    });
    await test.step('填写配置信息', async () => {
      const dialog = page.locator('.el-dialog');
      await dialog.locator('input').first().fill(configName);
      await dialog.locator('input').nth(1).fill(configKey);
      await dialog.locator('input').nth(2).fill(configValue);
    });
    await test.step('提交配置表单', async () => {
      await page.locator('.el-dialog button:has-text("确定")').click();
      await page.waitForSelector('.el-dialog', { state: 'hidden', timeout: 10000 });
      await expect(page.locator('.el-message--success')).toBeVisible({ timeout: 5000 });
    });
    await test.step('验证配置已创建', async () => {
      await page.waitForTimeout(2000);
      const configRow = page.locator(`tr:has-text("${configName}")`);
      await expect(configRow).toBeVisible({ timeout: 15000 });
    });
  });
  test('编辑参数配置', async ({ page }) => {
    const updatedValue = `updated_value_${timestamp}`;
    await test.step('导航到参数管理', async () => {
      await page.goto('/dashboard');
      await page.waitForLoadState('networkidle');
      await page.locator('text=系统管理').click();
      await page.waitForTimeout(500);
      await page.locator('text=参数管理').click();
      await page.waitForLoadState('networkidle');
    });
    await test.step('搜索并编辑配置', async () => {
      const configRow = page.locator(`tr:has-text("${configName}")`);
      await configRow.locator('button:has-text("编辑")').click();
      await page.waitForSelector('.el-dialog', { state: 'visible', timeout: 5000 });
    });
    await test.step('修改配置值', async () => {
      const dialog = page.locator('.el-dialog');
      await dialog.locator('input').nth(2).fill(updatedValue);
    });
    await test.step('提交更新', async () => {
      await page.locator('.el-dialog button:has-text("确定")').click();
      await page.waitForSelector('.el-dialog', { state: 'hidden', timeout: 10000 });
      await expect(page.locator('.el-message--success')).toBeVisible({ timeout: 5000 });
    });
    await test.step('验证配置已更新', async () => {
      await page.waitForTimeout(2000);
      const configRow = page.locator(`tr:has-text("${configName}")`);
      await expect(configRow).toBeVisible({ timeout: 15000 });
    });
  });
  test('删除参数配置', async ({ page }) => {
    await test.step('导航到参数管理', async () => {
      await page.goto('/dashboard');
      await page.waitForLoadState('networkidle');
      await page.locator('text=系统管理').click();
      await page.waitForTimeout(500);
      await page.locator('text=参数管理').click();
      await page.waitForLoadState('networkidle');
    });
    await test.step('搜索并删除配置', async () => {
      const configRow = page.locator(`tr:has-text("${configName}")`);
      await configRow.locator('button:has-text("删除")').click();
      await page.waitForSelector('.el-message-box', { state: 'visible', timeout: 5000 });
    });
    await test.step('确认删除', async () => {
      await page.locator('.el-message-box button:has-text("确定")').click();
      await page.waitForSelector('.el-message-box', { state: 'hidden', timeout: 10000 });
      await expect(page.locator('.el-message--success')).toBeVisible({ timeout: 5000 });
    });
    await test.step('验证配置已删除', async () => {
      await page.waitForTimeout(1000);
      const configRow = page.locator(`tr:has-text("${configName}")`);
      await expect(configRow).not.toBeVisible({ timeout: 5000 });
    });
  });
  test('参数管理权限验证', async ({ page }) => {
    await test.step('验证参数管理页面访问权限', async () => {
      await page.goto('/sys/config');
      await page.waitForLoadState('networkidle');
      await expect(page.locator('.el-card')).toBeVisible({ timeout: 5000 });
      await expect(page.locator('button:has-text("新增配置")')).toBeVisible();
    });
  });
 });
@@ -1,119 +0,0 @@
 import { test, expect } from '@playwright/test';
 test.describe('用户权限边界验证', () => {
  test('管理员可以访问所有管理功能', async ({ page }) => {
    await test.step('验证可以访问用户管理', async () => {
      await page.goto('/users');
      await page.waitForLoadState('networkidle');
      await expect(page).toHaveURL(/.*users/);
      await expect(page.locator('.el-table')).toBeVisible({ timeout: 10000 });
    });
    await test.step('验证可以访问角色管理', async () => {
      await page.goto('/roles');
      await page.waitForLoadState('networkidle');
      await expect(page).toHaveURL(/.*roles/);
      await expect(page.locator('.el-table')).toBeVisible({ timeout: 10000 });
    });
    await test.step('验证可以访问菜单管理', async () => {
      await page.goto('/menus');
      await page.waitForLoadState('networkidle');
      await expect(page).toHaveURL(/.*menus/);
      await expect(page.locator('.el-table')).toBeVisible({ timeout: 10000 });
    });
  });
  test('普通用户登录后可以访问页面但API操作受限', async ({ page }) => {
    await test.step('管理员登出', async () => {
      await page.goto('/dashboard');
      await page.waitForLoadState('domcontentloaded');
      await page.waitForTimeout(1000);
      const avatarButton = page.locator('.el-avatar').first();
      await avatarButton.click({ timeout: 10000 });
      await page.waitForTimeout(500);
      await page.locator('text=退出登录').click();
      await page.waitForURL(/.*login/, { timeout: 10000 });
    });
    await test.step('普通用户登录', async () => {
      await page.goto('/login');
      await page.waitForLoadState('domcontentloaded');
      await page.waitForTimeout(1000);
      const usernameInput = page.locator('input[placeholder*="用户名"]');
      const passwordInput = page.locator('input[placeholder*="密码"]');
      const loginButton = page.locator('button:has-text("登录")');
      await usernameInput.waitFor({ state: 'visible' });
      await usernameInput.fill('user');
      await passwordInput.waitFor({ state: 'visible' });
      await passwordInput.fill('Test@123');
      await loginButton.waitFor({ state: 'visible' });
      await loginButton.click();
      await page.waitForURL('**/dashboard', { timeout: 30000 });
    });
    await test.step('验证普通用户可以访问用户管理页面', async () => {
      await page.goto('/users');
      await page.waitForLoadState('networkidle');
      await expect(page).toHaveURL(/.*users/);
    });
    await test.step('验证普通用户无法创建用户', async () => {
      const createButton = page.locator('button:has-text("新增用户")');
      if (await createButton.isVisible()) {
        await createButton.click();
        await page.waitForTimeout(2000);
        const errorMessage = page.locator('.el-message--error');
        const hasError = await errorMessage.isVisible().catch(() => false);
        expect(hasError || await page.locator('.el-dialog').isVisible()).toBeTruthy();
      }
    });
  });
  test('权限不足时API返回403错误', async ({ page }) => {
    await test.step('管理员登出', async () => {
      await page.goto('/dashboard');
      await page.waitForLoadState('domcontentloaded');
      await page.waitForTimeout(1000);
      const avatarButton = page.locator('.el-avatar').first();
      await avatarButton.click({ timeout: 10000 });
      await page.waitForTimeout(500);
      await page.locator('text=退出登录').click();
      await page.waitForURL(/.*login/, { timeout: 10000 });
    });
    await test.step('普通用户登录', async () => {
      await page.goto('/login');
      await page.waitForLoadState('networkidle');
      const usernameInput = page.locator('input[placeholder*="用户名"]');
      const passwordInput = page.locator('input[placeholder*="密码"]');
      const loginButton = page.locator('button:has-text("登录")');
      await usernameInput.waitFor({ state: 'visible' });
      await usernameInput.fill('user');
      await passwordInput.waitFor({ state: 'visible' });
      await passwordInput.fill('Test@123');
      await loginButton.waitFor({ state: 'visible' });
      await loginButton.click();
      await page.waitForURL('**/dashboard', { timeout: 30000 });
    });
    await test.step('尝试访问受限API', async () => {
      const response = await page.request.get('/api/users?page=0&size=10');
      expect([200, 401, 403]).toContain(response.status());
    });
  });
 });
@@ -1,72 +0,0 @@
 import { test, expect } from '@playwright/test';
 test.describe('菜单管理功能测试', () => {
  let authToken: string;
  test.beforeAll(async ({ request }) => {
    const response = await request.post('http://localhost:8080/api/auth/login', {
      headers: {
        'Content-Type': 'application/json'
      },
      data: {
        username: 'admin',
        password: 'admin123'
      }
    });
    expect(response.status()).toBe(200);
    const data = await response.json();
    authToken = data.token;
  });
  test('菜单列表显示测试', async ({ page }) => {
    await test.step('导航到菜单管理页面', async () => {
      await page.goto('http://localhost:3002/login');
      const usernameInput = page.locator('input[type="text"], input[placeholder*="用户名"], input[placeholder*="账号"]').first();
      const passwordInput = page.locator('input[type="password"]').first();
      const loginButton = page.locator('button:has-text("登录")').first();
      await usernameInput.fill('admin');
      await passwordInput.fill('admin123');
      await loginButton.click();
      await page.waitForTimeout(2000);
      // 点击系统管理菜单
      const systemMenu = page.locator('.el-sub-menu:has-text("系统管理")').first();
      if (await systemMenu.count() > 0) {
        await systemMenu.click();
        await page.waitForTimeout(500);
      }
      // 点击菜单管理
      const menuManagement = page.locator('.el-menu-item:has-text("菜单管理")').first();
      if (await menuManagement.count() > 0) {
        await menuManagement.click();
        await page.waitForTimeout(1000);
      }
    });
    await test.step('验证菜单列表显示', async () => {
      // 检查是否有菜单列表或表格
      const tableSelectors = [
        'table',
        '.el-table',
        '[class*="table"]',
        '.menu-list'
      ];
      let foundTable = false;
      for (const selector of tableSelectors) {
        const count = await page.locator(selector).count();
        if (count > 0) {
          foundTable = true;
          break;
        }
      }
      expect(foundTable).toBe(true);
    });
  });
 });
@@ -1,130 +0,0 @@
 import { Page, Locator } from '@playwright/test';
 export class DashboardPage {
  readonly page: Page;
  readonly userInfo: Locator;
  readonly userManagementLink: Locator;
  readonly roleManagementLink: Locator;
  readonly menuManagementLink: Locator;
  readonly systemConfigLink: Locator;
  readonly noticeManagementLink: Locator;
  readonly fileManagementLink: Locator;
  readonly operationLogLink: Locator;
  readonly loginLogLink: Locator;
  readonly dictionaryLink: Locator;
  constructor(page: Page) {
    this.page = page;
    this.userInfo = page.locator('.el-avatar');
    this.userManagementLink = page.locator('.el-menu-item:has-text("用户管理")');
    this.roleManagementLink = page.locator('.el-menu-item:has-text("角色管理")');
    this.menuManagementLink = page.locator('.el-menu-item:has-text("菜单管理")');
    this.systemConfigLink = page.locator('.el-menu-item:has-text("参数配置")');
    this.noticeManagementLink = page.locator('.el-menu-item:has-text("通知公告")');
    this.fileManagementLink = page.locator('.el-menu-item:has-text("文件列表")');
    this.operationLogLink = page.locator('.el-menu-item:has-text("操作日志")');
    this.loginLogLink = page.locator('.el-menu-item:has-text("登录日志")');
    this.dictionaryLink = page.locator('.el-menu-item:has-text("字典管理")');
  }
  async goto() {
    await this.page.goto('/dashboard');
    await this.page.waitForLoadState('networkidle');
  }
  async navigateToUserManagement() {
    const systemMenu = this.page.locator('.el-sub-menu__title:has-text("系统管理")');
    await systemMenu.click();
    await this.page.waitForTimeout(1000);
    await this.userManagementLink.click();
    await this.page.waitForURL('**/users', { timeout: 30000 });
    await this.page.waitForLoadState('networkidle');
  }
  async navigateToRoleManagement() {
    const systemMenu = this.page.locator('.el-sub-menu__title:has-text("系统管理")');
    await systemMenu.click();
    await this.page.waitForTimeout(1000);
    await this.roleManagementLink.click();
    await this.page.waitForURL('**/roles', { timeout: 30000 });
    await this.page.waitForLoadState('networkidle');
  }
  async navigateToMenuManagement() {
    const systemMenu = this.page.locator('.el-sub-menu__title:has-text("系统管理")');
    await systemMenu.click();
    await this.page.waitForTimeout(1000);
    await this.menuManagementLink.click();
    await this.page.waitForURL('**/menus', { timeout: 30000 });
    await this.page.waitForLoadState('networkidle');
  }
  async navigateToSystemConfig() {
    const configMenu = this.page.locator('.el-sub-menu__title:has-text("系统配置")');
    await configMenu.click();
    await this.page.waitForTimeout(1000);
    await this.systemConfigLink.click();
    await this.page.waitForURL('**/sys/config', { timeout: 30000 });
    await this.page.waitForLoadState('networkidle');
  }
  async navigateToNoticeManagement() {
    const notifyMenu = this.page.locator('.el-sub-menu__title:has-text("通知中心")');
    await notifyMenu.click();
    await this.page.waitForTimeout(1000);
    await this.noticeManagementLink.click();
    await this.page.waitForURL('**/notice', { timeout: 30000 });
    await this.page.waitForLoadState('networkidle');
  }
  async navigateToFileManagement() {
    const fileMenu = this.page.locator('.el-sub-menu__title:has-text("文件管理")');
    await fileMenu.click();
    await this.page.waitForTimeout(1000);
    await this.fileManagementLink.click();
    await this.page.waitForURL('**/files', { timeout: 30000 });
    await this.page.waitForLoadState('networkidle');
  }
  async navigateToAudit() {
    const auditMenu = this.page.locator('.el-sub-menu__title:has-text("审计中心")');
    await auditMenu.click();
    await this.page.waitForTimeout(1000);
  }
  async navigateToOperationLog() {
    await this.navigateToAudit();
    await this.operationLogLink.click();
    await this.page.waitForURL('**/oplog', { timeout: 30000 });
    await this.page.waitForLoadState('networkidle');
  }
  async navigateToLoginLog() {
    await this.navigateToAudit();
    await this.loginLogLink.click();
    await this.page.waitForURL('**/loginlog', { timeout: 30000 });
    await this.page.waitForLoadState('networkidle');
  }
  async navigateToNotification() {
    const notifyMenu = this.page.locator('.el-sub-menu__title:has-text("通知中心")');
    await notifyMenu.click();
    await this.page.waitForTimeout(1000);
    await this.noticeManagementLink.click();
    await this.page.waitForURL('**/notification', { timeout: 30000 });
    await this.page.waitForLoadState('networkidle');
  }
  async navigateToDictionary() {
    const configMenu = this.page.locator('.el-sub-menu__title:has-text("系统配置")');
    await configMenu.click();
    await this.page.waitForTimeout(1000);
    await this.dictionaryLink.click();
    await this.page.waitForURL('**/dict', { timeout: 30000 });
    await this.page.waitForLoadState('networkidle');
  }
  async getUsername(): Promise<string | null> {
    return await this.userInfo.textContent();
  }
 }
@@ -1,97 +0,0 @@
 import { Page, Locator, expect } from '@playwright/test';
 export class DictionaryManagementPage {
  readonly page: Page;
  readonly table: Locator;
  readonly createDictButton: Locator;
  readonly saveButton: Locator;
  readonly dialog: Locator;
  readonly dictNameInput: Locator;
  readonly dictTypeInput: Locator;
  readonly statusSelect: Locator;
  readonly remarkInput: Locator;
  constructor(page: Page) {
    this.page = page;
    this.table = page.locator('.el-table');
    this.createDictButton = page.getByRole('button', { name: '新增字典' });
    this.saveButton = page.getByRole('button', { name: '确定' });
    this.dialog = page.locator('.el-dialog');
    this.dictNameInput = page.locator('.el-dialog').getByRole('textbox', { name: '字典名称' });
    this.dictTypeInput = page.locator('.el-dialog').getByRole('textbox', { name: '字典类型' });
    this.statusSelect = page.locator('.el-dialog').getByRole('combobox', { name: '状态' });
    this.remarkInput = page.locator('.el-dialog').getByRole('textbox', { name: '备注' });
  }
  async goto() {
    try {
      console.log('导航到字典管理页面...');
      await this.page.goto('/dict');
      await this.page.waitForLoadState('domcontentloaded');
      await this.page.waitForTimeout(1000);
      await this.table.waitFor({ state: 'visible', timeout: 15000 });
      await expect(this.page).toHaveURL(/.*dict/, { timeout: 15000 });
      console.log('字典管理页面加载完成');
    } catch (error) {
      await this.page.screenshot({ path: `test-results/dict-management-error-${Date.now()}.png` });
      console.error('导航到字典管理页面失败:', error);
      throw new Error(`导航到字典管理页面失败: ${error instanceof Error ? error.message : String(error)}`);
    }
  }
  async createDict(dictName: string, dictType: string, status: string = '0', remark?: string) {
    await this.createDictButton.click();
    await this.page.waitForTimeout(500);
    await this.dictNameInput.fill(dictName);
    await this.dictTypeInput.fill(dictType);
    if (status) {
      await this.statusSelect.click();
      await this.page.waitForTimeout(300);
      await this.page.getByRole('option', { name: status === '0' ? '正常' : '停用' }).click();
    }
    if (remark) {
      await this.remarkInput.fill(remark);
    }
    await this.saveButton.click();
    await this.page.waitForLoadState('networkidle');
  }
  async editDict(dictName: string, newDictName: string) {
    const row = this.table.locator('tr').filter({ hasText: dictName }).first();
    const editBtn = row.getByRole('button', { name: '编辑' });
    await editBtn.click();
    await this.page.waitForTimeout(500);
    await this.dictNameInput.clear();
    await this.dictNameInput.fill(newDictName);
    await this.saveButton.click();
    await this.page.waitForLoadState('networkidle');
  }
  async deleteDict(dictName: string) {
    const row = this.table.locator('tr').filter({ hasText: dictName }).first();
    const deleteBtn = row.getByRole('button', { name: '删除' });
    await deleteBtn.click();
    await this.page.waitForTimeout(500);
    const confirmBtn = this.page.locator('.el-message-box').getByRole('button', { name: '确定' });
    await confirmBtn.click();
    await this.page.waitForLoadState('networkidle');
  }
  async getDictCount() {
    const rows = await this.table.locator('.el-table__row').count();
    return rows;
  }
  async containsText(text: string): Promise<boolean> {
    return await this.table.getByText(text).count() > 0;
  }
 }
@@ -1,104 +0,0 @@
 import { Page, Locator, expect } from '@playwright/test';
 export class ExceptionLogPage {
  readonly page: Page;
  readonly table: Locator;
  readonly searchInput: Locator;
  readonly searchButton: Locator;
  readonly exportButton: Locator;
  readonly refreshButton: Locator;
  readonly detailButton: Locator;
  readonly successMessage: Locator;
  constructor(page: Page) {
    this.page = page;
    this.table = page.locator('.el-table').or(page.locator('.exception-log-table'));
    this.searchInput = page.locator('input[placeholder*="搜索"]').or(page.locator('input[name*="keyword"]'));
    this.searchButton = page.getByRole('button', { name: '搜索' }).or(page.locator('button:has-text("搜索")'));
    this.exportButton = page.getByRole('button', { name: '导出' }).or(page.locator('button:has-text("导出")'));
    this.refreshButton = page.getByRole('button', { name: '刷新' }).or(page.locator('button:has-text("刷新")'));
    this.detailButton = page.getByRole('button', { name: '详情' }).or(page.locator('.detail-button'));
    this.successMessage = page.locator('.el-message--success').or(page.locator('.success-message'));
  }
  async goto() {
    try {
      console.log('导航到异常日志页面...');
      await this.page.goto('/exceptionlog');
      await this.page.waitForLoadState('domcontentloaded');
      await this.page.waitForTimeout(1000);
      await this.table.waitFor({ state: 'visible', timeout: 15000 });
      await expect(this.page).toHaveURL(/.*exceptionlog/, { timeout: 15000 });
      console.log('异常日志页面加载完成');
    } catch (error) {
      if (!this.page.isClosed()) {
        await this.page.screenshot({ path: `test-results/exception-log-error-${Date.now()}.png` });
      }
      console.error('导航到异常日志页面失败:', error);
      throw new Error(`导航到异常日志页面失败: ${error instanceof Error ? error.message : String(error)}`);
    }
  }
  async search(keyword: string) {
    await this.searchInput.fill(keyword);
    await this.searchButton.click();
    await this.page.waitForTimeout(1000);
  }
  async clearSearch() {
    await this.searchInput.fill('');
    await this.searchButton.click();
    await this.page.waitForTimeout(1000);
  }
  async exportData() {
    await this.exportButton.click();
  }
  async refresh() {
    await this.refreshButton.click();
    await this.page.waitForLoadState('networkidle');
  }
  async viewDetail(exceptionId: string) {
    const exceptionRow = this.table.locator('tbody tr').filter({ hasText: exceptionId });
    await exceptionRow.locator('.detail-button').or(this.page.getByRole('button', { name: '详情' })).click();
  }
  async closeDetailDialog() {
    await this.page.getByRole('button', { name: '关闭' }).or(this.page.locator('.el-dialog .close-button')).click();
  }
  async containsText(text: string): Promise<boolean> {
    return await this.table.getByText(text).count() > 0;
  }
  async getTableRowCount(): Promise<number> {
    return await this.table.locator('tbody tr').count();
  }
  async isSuccessMessageVisible(): Promise<boolean> {
    try {
      return await this.successMessage.isVisible({ timeout: 3000 });
    } catch {
      return false;
    }
  }
  async reload() {
    await this.page.reload();
  }
  async verifyTableContains(text: string): Promise<void> {
    const contains = await this.containsText(text);
    if (!contains) {
      throw new Error(`Table does not contain text: ${text}`);
    }
  }
  async getLogCount(): Promise<number> {
    return await this.table.locator('tbody tr').count();
  }
 }
@@ -1,106 +0,0 @@
 import { Page, expect } from '@playwright/test';
 export class FileManagementPage {
  readonly page: Page;
  readonly uploadButton;
  readonly fileInput;
  readonly table;
  readonly deleteButton;
  readonly downloadButton;
  readonly searchInput;
  constructor(page: Page) {
    this.page = page;
    this.uploadButton = page.locator('.el-upload--text').first();
    this.fileInput = page.locator('input[type="file"]');
    this.table = page.locator('.el-table');
    this.deleteButton = page.getByRole('button', { name: '删除' });
    this.downloadButton = page.getByRole('button', { name: '下载' });
    this.searchInput = page.locator('.search-bar .el-input__inner');
  }
  async goto() {
    try {
      console.log('导航到文件管理页面...');
      await this.page.goto('/files');
      await this.page.waitForLoadState('networkidle');
      await this.table.waitFor({ state: 'visible', timeout: 10000 });
      await expect(this.page).toHaveURL(/.*files/);
      console.log('文件管理页面加载完成');
    } catch (error) {
      await this.page.screenshot({ path: `test-results/file-management-error-${Date.now()}.png` });
      console.error('导航到文件管理页面失败:', error);
      throw new Error(`导航到文件管理页面失败: ${error instanceof Error ? error.message : String(error)}`);
    }
  }
  async uploadFile(filePath: string) {
    await this.uploadButton.waitFor({ state: 'visible', timeout: 10000 });
    await this.uploadButton.click();
    const fileInput = this.page.locator('input[type="file"]');
    await fileInput.setInputFiles(filePath);
    await this.page.waitForTimeout(1000);
  }
  async deleteFile(fileName: string) {
    const row = this.table.locator('tr').filter({ hasText: fileName }).first();
    await row.locator('.el-button--danger').click();
    const confirmButton = this.page.getByRole('button', { name: '确定' });
    await confirmButton.click();
    await this.page.waitForLoadState('networkidle');
  }
  async downloadFile(fileName: string) {
    const row = this.table.locator('tr').filter({ hasText: fileName }).first();
    const downloadButton = row.locator('.el-button--primary').first();
    await downloadButton.click();
  }
  async searchFile(keyword: string) {
    await this.searchInput.fill(keyword);
    await this.page.waitForTimeout(500);
  }
  async clearSearch() {
    await this.searchInput.clear();
    await this.page.waitForTimeout(500);
  }
  async verifyTableContains(text: string) {
    await expect(this.table).toContainText(text);
  }
  async verifyTableNotContains(text: string) {
    await expect(this.table).not.toContainText(text);
  }
  async getTableRowCount() {
    const rows = await this.table.locator('.el-table__row').count();
    return rows;
  }
  async clickUploadButton() {
    await this.uploadButton.waitFor({ state: 'visible', timeout: 10000 });
    await this.uploadButton.click();
  }
  async submitUpload() {
    const confirmButton = this.page.getByRole('button', { name: '确定' }).or(this.page.locator('.el-dialog .el-button--primary'));
    await confirmButton.click();
  }
  async clickDeleteButton(rowNumber: number) {
    const row = this.table.locator(`tbody tr:nth-child(${rowNumber})`);
    await row.locator('.el-button--danger').click();
  }
  async clickDownloadButton(rowNumber: number) {
    const row = this.table.locator(`tbody tr:nth-child(${rowNumber})`);
    await row.locator('.el-button--primary').first().click();
  }
 }
@@ -1,63 +0,0 @@
 import { Page, expect } from '@playwright/test';
 export class LoginLogPage {
  readonly page: Page;
  readonly searchInput;
  readonly searchButton;
  readonly table;
  readonly exportButton;
  constructor(page: Page) {
    this.page = page;
    this.searchInput = page.getByPlaceholder('搜索用户名或IP地址');
    this.searchButton = page.getByRole('button', { name: '搜索' });
    this.table = page.locator('.el-table');
    this.exportButton = page.getByRole('button', { name: '导出' });
  }
  async goto() {
    try {
      console.log('导航到登录日志页面...');
      await this.page.goto('/loginlog');
      await this.page.waitForLoadState('networkidle');
      await this.table.waitFor({ state: 'visible', timeout: 10000 });
      await expect(this.page).toHaveURL(/.*loginlog/);
      console.log('登录日志页面加载完成');
    } catch (error) {
      await this.page.screenshot({ path: `test-results/login-log-error-${Date.now()}.png` });
      console.error('导航到登录日志页面失败:', error);
      throw new Error(`导航到登录日志页面失败: ${error instanceof Error ? error.message : String(error)}`);
    }
  }
  async searchByKeyword(keyword: string) {
    await this.searchInput.fill(keyword);
    await this.searchButton.click();
    await this.page.waitForLoadState('networkidle');
  }
  async clearSearch() {
    await this.searchInput.clear();
    await this.searchButton.click();
    await this.page.waitForLoadState('networkidle');
  }
  async verifyTableContains(text: string) {
    await expect(this.table).toContainText(text);
  }
  async verifyTableNotContains(text: string) {
    await expect(this.table).not.toContainText(text);
  }
  async getTableRowCount() {
    const rows = await this.table.locator('.el-table__row').count();
    return rows;
  }
  async exportData() {
    await this.exportButton.click();
  }
 }
--- a/Show More
+++ b/Show More
		`@@ -1 +0,0 @@`
			`This is a test file for E2E testing purposes.`
		`@@ -1,3 +0,0 @@`
			`import { globalTeardown } from './global-setup';`

			`export default globalTeardown;`