feat: 完成sys模块迁移，对齐PHP/Java框架

- 重构sys模块架构，严格按admin/api/core分层
- 对齐所有sys实体与数据库表结构
- 实现完整的adminapi控制器，匹配PHP/Java契约
- 修复依赖注入问题，确保服务正确注册
- 添加自动迁移工具和契约验证
- 完善多租户支持和审计功能
- 统一命名规范，与PHP业务逻辑保持一致

wwjcloud/test/queue/queue-system.e2e-spec.ts

@@ -4,18 +4,15 @@ import request from 'supertest';
 import { TestModule } from '../test.module';
 import { TestService } from '../test.service';
 import { UnifiedQueueService } from '../../src/core/queue/unifiedQueueService';
-import { DatabaseQueueProvider } from '../../src/core/queue/databaseQueueProvider';
-import { QueueModule } from '../../src/core/queue/queueModule';
 
 describe('Queue System (e2e)', () => {
   let app: INestApplication;
   let testService: TestService;
   let unifiedQueueService: UnifiedQueueService;
-  let databaseQueueProvider: DatabaseQueueProvider;
 
   beforeAll(async () => {
     const moduleFixture: TestingModule = await Test.createTestingModule({
-      imports: [TestModule, QueueModule],
+      imports: [TestModule],
     }).compile();
 
     app = moduleFixture.createNestApplication();
@@ -24,9 +21,6 @@ describe('Queue System (e2e)', () => {
     testService = moduleFixture.get<TestService>(TestService);
     unifiedQueueService =
       moduleFixture.get<UnifiedQueueService>(UnifiedQueueService);
-    databaseQueueProvider = moduleFixture.get<DatabaseQueueProvider>(
-      DatabaseQueueProvider,
-    );
   });
 
   afterAll(async () => {
@@ -84,13 +78,18 @@ describe('Queue System (e2e)', () => {
     });
 
     it('should add task to queue', async () => {
-      const result = await unifiedQueueService.addTask('test-queue', {
-        data: { test: 'data' },
-        priority: 1,
-        delay: 0,
-        attempts: 3,
-      });
-      expect(result).toBeDefined();
+      await expect(
+        unifiedQueueService.addTask(
+          'test-queue',
+          'test-task',
+          { test: 'data' },
+          {
+            priority: 1,
+            delay: 0,
+            attempts: 3,
+          },
+        ),
+      ).resolves.toBeUndefined();
     });
 
     it('should process task from queue', async () => {
@@ -102,13 +101,17 @@ describe('Queue System (e2e)', () => {
       });
 
       // Add a task to be processed
-      await unifiedQueueService.addTask('test-queue', {
-        data: { test: 'process-data' },
-        priority: 1,
-      });
+      await unifiedQueueService.addTask(
+        'test-queue',
+        'process-task',
+        { test: 'process-data' },
+        {
+          priority: 1,
+        },
+      );
 
       // Wait a bit for processing
-      await new Promise((resolve) => setTimeout(resolve, 1000));
+      await new Promise((resolve) => setTimeout(resolve, 300));
 
       expect(processedData).toBeDefined();
     });
@@ -132,53 +135,10 @@ describe('Queue System (e2e)', () => {
     });
   });
 
-  describe('DatabaseQueueProvider', () => {
-    it('should be defined', () => {
-      expect(databaseQueueProvider).toBeDefined();
-    });
-
-    it('should add job to database queue', async () => {
-      const jobData = {
-        type: 'test-job',
-        payload: { test: 'database-job' },
-        options: {
-          priority: 1,
-          delay: 0,
-          attempts: 3,
-        },
-      };
-
-      const result = await databaseQueueProvider.add(
-        'test-db-queue',
-        jobData.type,
-        jobData.payload,
-        jobData.options,
-      );
-      expect(result).toBeDefined();
-    });
-
-    it('should publish event to database', async () => {
-      const event = {
-        eventType: 'test.database.event',
-        aggregateId: 'db-test-123',
-        aggregateType: 'DatabaseTest',
-        version: '1.0',
-        occurredAt: new Date().toISOString(),
-        tenantId: 'tenant-1',
-        idempotencyKey: 'db-key-123',
-        traceId: 'db-trace-123',
-        data: { test: 'database-event-data' },
-      };
-
-      await expect(databaseQueueProvider.publish(event)).resolves.not.toThrow();
-    });
-  });
-
   describe('Service Integration', () => {
     it('should have all required services available', () => {
       expect(testService).toBeDefined();
       expect(unifiedQueueService).toBeDefined();
-      expect(databaseQueueProvider).toBeDefined();
     });
   });
 
@@ -188,11 +148,16 @@ describe('Queue System (e2e)', () => {
       const taskData = { workflow: 'test', step: 1 };
 
       // Add task
-      const taskResult = await unifiedQueueService.addTask('workflow-queue', {
-        data: taskData,
-        priority: 1,
-      });
-      expect(taskResult).toBeDefined();
+      await expect(
+        unifiedQueueService.addTask(
+          'workflow-queue',
+          'workflow-task',
+          taskData,
+          {
+            priority: 1,
+          },
+        ),
+      ).resolves.toBeUndefined();
 
       // Process task and publish event
       await unifiedQueueService.processTask(
@@ -216,7 +181,7 @@ describe('Queue System (e2e)', () => {
       );
 
       // Wait for processing
-      await new Promise((resolve) => setTimeout(resolve, 1000));
+      await new Promise((resolve) => setTimeout(resolve, 300));
     });
 
     it('should handle error scenarios gracefully', async () => {
@@ -229,14 +194,18 @@ describe('Queue System (e2e)', () => {
       });
 
       // Add a failing task
-      await unifiedQueueService.addTask('error-queue', {
-        data: { shouldFail: true },
-        priority: 1,
-        attempts: 1, // Only try once
-      });
+      await unifiedQueueService.addTask(
+        'error-queue',
+        'error',
+        { shouldFail: true },
+        {
+          priority: 1,
+          attempts: 1, // Only try once
+        },
+      );
 
       // Wait for processing attempt
-      await new Promise((resolve) => setTimeout(resolve, 1000));
+      await new Promise((resolve) => setTimeout(resolve, 300));
 
       // The test passes if no unhandled errors are thrown
       expect(true).toBe(true);