@nest-omni/core 4.1.3-11 → 4.1.3-13

package/{audit → dist/audit}/services/entity-audit.service.d.ts

@@ -1,5 +1,5 @@
 import { Repository, EntityManager } from 'typeorm';
-import { EntityAuditLogEntity, EntityTransactionEntity, ManualOperationLogEntity } from '../entities';
+import { EntityAuditLogEntity, EntityTransactionEntity, ManualOperationLogEntity, AuditActionSummaryEntity } from '../entities';
 import { AuditOperation } from '../enums';
 import { AuditConfig, IAuditStrategy, EntityDifference, RestoreOptions, RestoreResult, PreCheckResult, ManualOperationData, ChangeDetail, RollbackAction } from '../interfaces';
 import { AuditContextService } from './audit-context.service';
@@ -18,8 +18,9 @@ export declare class EntityAuditService {
     private readonly multiDbService;
     private readonly auditStrategy;
     private readonly config?;
+    private readonly actionSummaryRepository?;
     private readonly auditConnectionName;
-    constructor(auditLogRepository: Repository<EntityAuditLogEntity>, transactionRepository: Repository<EntityTransactionEntity>, manualOperationRepository: Repository<ManualOperationLogEntity>, entityManager: EntityManager, contextService: AuditContextService, multiDbService: MultiDatabaseService, auditStrategy?: IAuditStrategy, config?: AuditConfig, auditConnectionName?: string);
+    constructor(auditLogRepository: Repository<EntityAuditLogEntity>, transactionRepository: Repository<EntityTransactionEntity>, manualOperationRepository: Repository<ManualOperationLogEntity>, entityManager: EntityManager, contextService: AuditContextService, multiDbService: MultiDatabaseService, auditStrategy?: IAuditStrategy, config?: AuditConfig, auditConnectionName?: string, actionSummaryRepository?: Repository<AuditActionSummaryEntity>);
     /**
      * 记录实体变更
      */
@@ -85,7 +86,13 @@ export declare class EntityAuditService {
      */
     private generateHashChain;
     /**
-     * 生成描述
+     * 生成描述（支持多语言）
+     * @param operation 操作类型
+     * @param entityType 实体类型
+     * @param entityId 实体ID
+     * @param changedFields 变更字段列表
+     * @param language 语言（默认中文）
+     * @param entityClass 实体类（可选，用于获取实体标签）
      */
     private generateDescription;
     /**
@@ -160,4 +167,98 @@ export declare class EntityAuditService {
      * @param transactionId 事务ID
      */
     rollbackTransaction(transactionId: string): Promise<void>;
+    /**
+     * 查询审计动作汇总记录
+     */
+    getAuditActions(options: {
+        userId?: string;
+        username?: string;
+        actionName?: string;
+        success?: boolean;
+        startTime?: Date;
+        endTime?: Date;
+        page?: number;
+        limit?: number;
+    }): Promise<PageDto<AuditActionSummaryEntity>>;
+    /**
+     * 查询单个审计动作的详细信息（包含关联的实体变更）
+     */
+    getAuditActionDetail(actionId: string): Promise<{
+        summary: {
+            id: string;
+            actionName: string;
+            operationTemplateKey: string;
+            description: string;
+            descriptionParams: Record<string, any>;
+            success: boolean;
+            errorMessage: string;
+            duration: number;
+            userId: string;
+            username: string;
+            requestId: string;
+            requestIp: string;
+            userAgent: string;
+            entityChangesCount: number;
+            entityTypes: string[];
+            operationStats: Record<string, number>;
+            createdAt: Date;
+            metadata: Record<string, any>;
+        };
+        entityChanges: EntityAuditLogEntity[];
+        detailedChanges: {
+            id: string;
+            entityType: string;
+            entityId: string;
+            operation: AuditOperation;
+            operationLabel: string;
+            description: string;
+            sequenceInAction: number;
+            createdAt: Date;
+            oldValue: Record<string, any>;
+            newValue: Record<string, any>;
+            fieldChanges: {
+                field: string;
+                fieldLabel: string;
+                oldValue: any;
+                newValue: any;
+                changeType: "added" | "removed" | "modified" | "unchanged";
+                displayOldValue?: string;
+                displayNewValue?: string;
+            }[];
+            changedFieldsCount: number;
+            changedFields: string[];
+        }[];
+        statistics: {
+            totalChanges: number;
+            totalFieldChanges: number;
+            byEntityType: Record<string, number>;
+            byOperation: Record<string, number>;
+            operationSequence: {
+                sequence: number;
+                entityType: string;
+                operation: AuditOperation;
+            }[];
+        };
+    }>;
+    /**
+     * 分析字段变化（支持多语言）
+     * @param oldValue 旧值
+     * @param newValue 新值
+     * @param operation 操作类型
+     * @param entityClass 实体类（可选，用于获取字段和值的多语言标签）
+     * @param language 语言（默认中文）
+     */
+    private analyzeFieldChanges;
+    /**
+     * 格式化显示值
+     */
+    private formatDisplayValue;
+    /**
+     * 获取操作标签
+     */
+    private getOperationLabel;
+    /**
+     * 按字段分组统计
+     */
+    private groupBy;
 }

package/{audit → dist/audit}/services/entity-audit.service.js

@@ -32,11 +32,12 @@ const audit_context_service_1 = require("./audit-context.service");
 const audit_strategy_service_1 = require("./audit-strategy.service");
 const multi_database_service_1 = require("./multi-database.service");
 const dto_1 = require("../../common/dto");
+const entity_audit_decorator_1 = require("../decorators/entity-audit.decorator");
 /**
  * 实体审计服务
  */
 let EntityAuditService = class EntityAuditService {
-    constructor(auditLogRepository, transactionRepository, manualOperationRepository, entityManager, contextService, multiDbService, auditStrategy = new audit_strategy_service_1.DefaultAuditStrategy(), config, auditConnectionName) {
+    constructor(auditLogRepository, transactionRepository, manualOperationRepository, entityManager, contextService, multiDbService, auditStrategy = new audit_strategy_service_1.DefaultAuditStrategy(), config, auditConnectionName, actionSummaryRepository) {
         this.auditLogRepository = auditLogRepository;
         this.transactionRepository = transactionRepository;
         this.manualOperationRepository = manualOperationRepository;
@@ -45,6 +46,7 @@ let EntityAuditService = class EntityAuditService {
         this.multiDbService = multiDbService;
         this.auditStrategy = auditStrategy;
         this.config = config;
+        this.actionSummaryRepository = actionSummaryRepository;
         this.auditConnectionName = auditConnectionName || 'default';
     }
     /**
@@ -90,6 +92,10 @@ let EntityAuditService = class EntityAuditService {
                 hashChain: ((_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.security) === null || _b === void 0 ? void 0 : _b.hashChainEnabled)
                     ? yield this.generateHashChain(entityType, entityId, filteredNewValue)
                     : undefined,
+                // 新增：审计动作关联字段
+                auditActionId: metadata.auditActionId,
+                auditActionName: metadata.auditActionName,
+                sequenceInAction: metadata.sequenceInAction || 0,
             });
             // 保存变更日志
             const savedLog = yield this.auditLogRepository.save(auditLog);
@@ -338,7 +344,7 @@ let EntityAuditService = class EntityAuditService {
     /**
      * 深度差异比较
      */
-    deepDiff(oldObj, newObj, path = []) {
+    deepDiff(oldObj, newObj, path = [], visited = new WeakSet()) {
         var _a;
         const changes = [];
         const maxDepth = ((_a = this.config) === null || _a === void 0 ? void 0 : _a.maxDiffDepth) || 5;
@@ -358,6 +364,19 @@ let EntityAuditService = class EntityAuditService {
             }
             return changes;
         }
+        // 检测循环引用
+        if (visited.has(oldObj)) {
+            // 检测到循环引用,停止递归
+            return changes;
+        }
+        visited.add(oldObj);
+        // 如果newObj也是对象,也加入访问集合
+        if (typeof newObj === 'object' && newObj !== null) {
+            if (visited.has(newObj)) {
+                return changes;
+            }
+            visited.add(newObj);
+        }
         // 处理数组
         if (Array.isArray(oldObj)) {
             if (!Array.isArray(newObj)) {
@@ -379,7 +398,7 @@ let EntityAuditService = class EntityAuditService {
                 return changes;
             }
             for (let i = 0; i < oldObj.length; i++) {
-                changes.push(...this.deepDiff(oldObj[i], newObj[i], [...path, i.toString()]));
+                changes.push(...this.deepDiff(oldObj[i], newObj[i], [...path, i.toString()], visited));
             }
             return changes;
         }
@@ -405,7 +424,7 @@ let EntityAuditService = class EntityAuditService {
                 });
             }
             else {
-                changes.push(...this.deepDiff(oldVal, newVal, [...path, key]));
+                changes.push(...this.deepDiff(oldVal, newVal, [...path, key], visited));
             }
         }
         return changes;
@@ -522,9 +541,15 @@ let EntityAuditService = class EntityAuditService {
         });
     }
     /**
-     * 生成描述
+     * 生成描述（支持多语言）
+     * @param operation 操作类型
+     * @param entityType 实体类型
+     * @param entityId 实体ID
+     * @param changedFields 变更字段列表
+     * @param language 语言（默认中文）
+     * @param entityClass 实体类（可选，用于获取实体标签）
      */
-    generateDescription(operation, entityType, entityId, changedFields) {
+    generateDescription(operation, entityType, entityId, changedFields, language = 'zh', entityClass) {
         const operationText = {
             [enums_1.AuditOperation.CREATE]: '创建',
             [enums_1.AuditOperation.UPDATE]: '更新',
@@ -532,10 +557,32 @@ let EntityAuditService = class EntityAuditService {
             [enums_1.AuditOperation.RESTORE]: '恢复',
         };
         const text = operationText[operation] || operation;
+        // 尝试获取实体的多语言标签
+        let entityLabel = entityType;
+        if (entityClass) {
+            try {
+                entityLabel = (0, entity_audit_decorator_1.getEntityLabel)(entityClass, language);
+            }
+            catch (error) {
+                // 忽略错误，使用默认的 entityType
+            }
+        }
         if (operation === enums_1.AuditOperation.UPDATE && changedFields.length > 0) {
-            return `${text} ${entityType}(${entityId}), 变更字段: ${changedFields.join(', ')}`;
+            // 对于更新操作，显示哪些字段发生了变化
+            const fieldLabels = changedFields.map(field => {
+                if (entityClass) {
+                    try {
+                        return (0, entity_audit_decorator_1.getFieldLabel)(entityClass, field, language);
+                    }
+                    catch (error) {
+                        return field;
+                    }
+                }
+                return field;
+            });
+            return `${text}${entityLabel}(${entityId}), 变更字段: ${fieldLabels.join('、')}`;
         }
-        return `${text} ${entityType}(${entityId})`;
+        return `${text}${entityLabel}(${entityId})`;
     }
     /**
      * 检测冲突
@@ -756,6 +803,254 @@ let EntityAuditService = class EntityAuditService {
             });
         });
     }
+    /**
+     * 查询审计动作汇总记录
+     */
+    getAuditActions(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.actionSummaryRepository) {
+                throw new Error('AuditActionSummaryEntity repository not available');
+            }
+            const { page = 1, limit = 20 } = options;
+            const queryBuilder = this.actionSummaryRepository.createQueryBuilder('action');
+            // 应用过滤条件
+            if (options.userId) {
+                queryBuilder.andWhere('action.userId = :userId', { userId: options.userId });
+            }
+            if (options.username) {
+                queryBuilder.andWhere('action.username LIKE :username', { username: `%${options.username}%` });
+            }
+            if (options.actionName) {
+                queryBuilder.andWhere('action.actionName = :actionName', { actionName: options.actionName });
+            }
+            if (options.success !== undefined) {
+                queryBuilder.andWhere('action.success = :success', { success: options.success });
+            }
+            if (options.startTime && options.endTime) {
+                queryBuilder.andWhere('action.createdAt BETWEEN :startTime AND :endTime', {
+                    startTime: options.startTime,
+                    endTime: options.endTime,
+                });
+            }
+            // 排序
+            queryBuilder.orderBy('action.createdAt', 'DESC');
+            // 分页
+            const skip = (page - 1) * limit;
+            queryBuilder.skip(skip).take(limit);
+            const [data, total] = yield queryBuilder.getManyAndCount();
+            const pageOptionsDto = new dto_1.PageOptionsDto();
+            Object.assign(pageOptionsDto, { page, pageSize: limit });
+            const pageMetaDto = new dto_1.PageMetaDto({
+                pageOptionsDto,
+                itemCount: total,
+            });
+            return new dto_1.PageDto(data, pageMetaDto);
+        });
+    }
+    /**
+     * 查询单个审计动作的详细信息（包含关联的实体变更）
+     */
+    getAuditActionDetail(actionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.actionSummaryRepository) {
+                throw new Error('AuditActionSummaryEntity repository not available');
+            }
+            // 查询汇总信息
+            const summary = yield this.actionSummaryRepository.findOne({
+                where: { id: actionId },
+            });
+            if (!summary) {
+                throw new Error(`Audit action with id ${actionId} not found`);
+            }
+            // 查询关联的实体变更
+            const entityChanges = yield this.auditLogRepository.find({
+                where: { auditActionId: actionId },
+                order: { sequenceInAction: 'ASC' },
+            });
+            // 分析每个实体的详细变化
+            const detailedChanges = entityChanges.map((change) => {
+                const fieldChanges = this.analyzeFieldChanges(change.oldValue || {}, change.newValue || {}, change.operation);
+                return {
+                    id: change.id,
+                    entityType: change.entityType,
+                    entityId: change.entityId,
+                    operation: change.operation,
+                    operationLabel: this.getOperationLabel(change.operation),
+                    description: change.description,
+                    sequenceInAction: change.sequenceInAction,
+                    createdAt: change.createdAt,
+                    // 数据快照
+                    oldValue: change.oldValue,
+                    newValue: change.newValue,
+                    // 详细的字段变化分析
+                    fieldChanges,
+                    changedFieldsCount: fieldChanges.length,
+                    changedFields: change.changedFields,
+                };
+            });
+            // 统计信息
+            const statistics = {
+                totalChanges: entityChanges.length,
+                totalFieldChanges: detailedChanges.reduce((sum, c) => sum + c.changedFieldsCount, 0),
+                byEntityType: this.groupBy(entityChanges, 'entityType'),
+                byOperation: this.groupBy(entityChanges, 'operation'),
+                operationSequence: entityChanges.map((c) => ({
+                    sequence: c.sequenceInAction,
+                    entityType: c.entityType,
+                    operation: c.operation,
+                })),
+            };
+            return {
+                // 汇总信息
+                summary: {
+                    id: summary.id,
+                    actionName: summary.actionName,
+                    operationTemplateKey: summary.operationTemplateKey,
+                    description: summary.description,
+                    descriptionParams: summary.descriptionParams,
+                    success: summary.success,
+                    errorMessage: summary.errorMessage,
+                    duration: summary.duration,
+                    userId: summary.userId,
+                    username: summary.username,
+                    requestId: summary.requestId,
+                    requestIp: summary.requestIp,
+                    userAgent: summary.userAgent,
+                    entityChangesCount: summary.entityChangesCount,
+                    entityTypes: summary.entityTypes,
+                    operationStats: summary.operationStats,
+                    createdAt: summary.createdAt,
+                    metadata: summary.metadata,
+                },
+                // 原始实体变更记录
+                entityChanges,
+                // 详细的变化分析
+                detailedChanges,
+                // 统计信息
+                statistics,
+            };
+        });
+    }
+    /**
+     * 分析字段变化（支持多语言）
+     * @param oldValue 旧值
+     * @param newValue 新值
+     * @param operation 操作类型
+     * @param entityClass 实体类（可选，用于获取字段和值的多语言标签）
+     * @param language 语言（默认中文）
+     */
+    analyzeFieldChanges(oldValue, newValue, operation, entityClass, language = 'zh') {
+        const changes = [];
+        const allFields = new Set([...Object.keys(oldValue), ...Object.keys(newValue)]);
+        for (const field of allFields) {
+            const oldVal = oldValue[field];
+            const newVal = newValue[field];
+            let changeType;
+            if (operation === enums_1.AuditOperation.CREATE) {
+                // 创建操作，所有字段都是新增
+                changeType = 'added';
+            }
+            else if (operation === enums_1.AuditOperation.DELETE) {
+                // 删除操作，所有字段都是移除
+                changeType = 'removed';
+            }
+            else {
+                // 更新操作，判断字段变化
+                if (oldVal === undefined && newVal !== undefined) {
+                    changeType = 'added';
+                }
+                else if (oldVal !== undefined && newVal === undefined) {
+                    changeType = 'removed';
+                }
+                else if (JSON.stringify(oldVal) !== JSON.stringify(newVal)) {
+                    changeType = 'modified';
+                }
+                else {
+                    changeType = 'unchanged';
+                }
+            }
+            // 跳过未变化的字段（对于UPDATE操作）
+            if (changeType === 'unchanged' && operation === enums_1.AuditOperation.UPDATE) {
+                continue;
+            }
+            // 获取字段的多语言标签
+            let fieldLabel = field;
+            if (entityClass) {
+                try {
+                    fieldLabel = (0, entity_audit_decorator_1.getFieldLabel)(entityClass, field, language);
+                }
+                catch (error) {
+                    // 忽略错误，使用原字段名
+                }
+            }
+            // 获取字段值的多语言标签
+            let displayOldValue = this.formatDisplayValue(oldVal);
+            let displayNewValue = this.formatDisplayValue(newVal);
+            if (entityClass) {
+                try {
+                    if (oldVal !== null && oldVal !== undefined) {
+                        const valueLabel = (0, entity_audit_decorator_1.getFieldValueLabel)(entityClass, field, oldVal, language);
+                        if (valueLabel !== oldVal) {
+                            displayOldValue = valueLabel;
+                        }
+                    }
+                    if (newVal !== null && newVal !== undefined) {
+                        const valueLabel = (0, entity_audit_decorator_1.getFieldValueLabel)(entityClass, field, newVal, language);
+                        if (valueLabel !== newVal) {
+                            displayNewValue = valueLabel;
+                        }
+                    }
+                }
+                catch (error) {
+                    // 忽略错误，使用默认格式化值
+                }
+            }
+            changes.push({
+                field,
+                fieldLabel,
+                oldValue: oldVal,
+                newValue: newVal,
+                changeType,
+                displayOldValue,
+                displayNewValue,
+            });
+        }
+        return changes;
+    }
+    /**
+     * 格式化显示值
+     */
+    formatDisplayValue(value) {
+        if (value === null || value === undefined) {
+            return '';
+        }
+        if (typeof value === 'object') {
+            return JSON.stringify(value);
+        }
+        return String(value);
+    }
+    /**
+     * 获取操作标签
+     */
+    getOperationLabel(operation) {
+        const labels = {
+            [enums_1.AuditOperation.CREATE]: '创建',
+            [enums_1.AuditOperation.UPDATE]: '更新',
+            [enums_1.AuditOperation.DELETE]: '删除',
+            [enums_1.AuditOperation.RESTORE]: '恢复',
+        };
+        return labels[operation] || operation;
+    }
+    /**
+     * 按字段分组统计
+     */
+    groupBy(items, field) {
+        return items.reduce((acc, item) => {
+            const key = item[field];
+            acc[key] = (acc[key] || 0) + 1;
+            return acc;
+        }, {});
+    }
 };
 exports.EntityAuditService = EntityAuditService;
 exports.EntityAuditService = EntityAuditService = __decorate([
@@ -770,10 +1065,12 @@ exports.EntityAuditService = EntityAuditService = __decorate([
     __param(7, (0, common_1.Inject)('AUDIT_CONFIG')),
     __param(8, (0, common_1.Optional)()),
     __param(8, (0, common_1.Inject)('AUDIT_CONNECTION_NAME')),
+    __param(9, (0, common_1.Optional)()),
+    __param(9, (0, typeorm_1.InjectRepository)(entities_1.AuditActionSummaryEntity)),
     __metadata("design:paramtypes", [typeorm_2.Repository,
         typeorm_2.Repository,
         typeorm_2.Repository,
         typeorm_2.EntityManager,
         audit_context_service_1.AuditContextService,
-        multi_database_service_1.MultiDatabaseService, Object, Object, String])
+        multi_database_service_1.MultiDatabaseService, Object, Object, String, typeorm_2.Repository])
 ], EntityAuditService);

package/{audit → dist/audit}/services/index.d.ts

@@ -5,3 +5,4 @@ export * from './transaction-audit.service';
 export * from './multi-database.service';
 export * from './operation-description.service';
 export * from './manual-audit-log.service';
+export * from './audit-action.service';

package/{audit → dist/audit}/services/index.js

@@ -21,3 +21,4 @@ __exportStar(require("./transaction-audit.service"), exports);
 __exportStar(require("./multi-database.service"), exports);
 __exportStar(require("./operation-description.service"), exports);
 __exportStar(require("./manual-audit-log.service"), exports);
+__exportStar(require("./audit-action.service"), exports);

package/{audit → dist/audit}/services/manual-audit-log.service.d.ts

@@ -2,20 +2,21 @@ import { Repository, DataSource } from 'typeorm';
 import { ManualOperationLogEntity, EntityTransactionEntity } from '../entities';
 import { AuditContextService } from './audit-context.service';
 import { ManualLogOptions } from '../interfaces';
+import { AuditTransactionStatus } from '../enums';
 /**
  * 手动审计日志服务
  *
- * 提供全局静态方法，在任意地方手动记录操作日志
+ * 提供标准的依赖注入方式记录操作日志
+ * @deprecated 静态方法已废弃,请使用依赖注入方式
  */
 export declare class ManualAuditLogService {
     private readonly manualLogRepository;
     private readonly transactionRepository;
     private readonly contextService;
     private readonly dataSource;
-    private static instance;
     constructor(manualLogRepository: Repository<ManualOperationLogEntity>, transactionRepository: Repository<EntityTransactionEntity>, contextService: AuditContextService, dataSource: DataSource);
     /**
-     * 全局静态方法：记录操作日志
+     * 记录操作日志
      *
      * @description
      * 支持三种记录模式：
@@ -25,7 +26,7 @@ export declare class ManualAuditLogService {
      *
      * @example
      * // 模式1：模板键模式
-     * await ManualAuditLogService.log({
+     * await this.manualAuditLogService.log({
      *   templateKey: 'user.login',
      *   descriptionParams: {
      *     username: 'john.doe',
@@ -35,13 +36,13 @@ export declare class ManualAuditLogService {
      *
      * @example
      * // 模式2：直接描述模式（字符串）
-     * await ManualAuditLogService.log({
+     * await this.manualAuditLogService.log({
      *   description: '用户登录系统',
      * });
      *
      * @example
      * // 模式2：直接描述模式（多语言）
-     * await ManualAuditLogService.log({
+     * await this.manualAuditLogService.log({
      *   description: {
      *     zh: '用户登录系统',
      *     en: 'User logged in',
@@ -50,7 +51,7 @@ export declare class ManualAuditLogService {
      *
      * @example
      * // 模式3：内联模板模式
-     * await ManualAuditLogService.log({
+     * await this.manualAuditLogService.log({
      *   descriptionTemplate: {
      *     zh: '用户 {username} 在 {time} 登录了系统',
      *     en: 'User {username} logged in at {time}',
@@ -61,52 +62,52 @@ export declare class ManualAuditLogService {
      *   },
      * });
      */
-    static log(options: ManualLogOptions): Promise<ManualOperationLogEntity>;
+    log(options: ManualLogOptions): Promise<ManualOperationLogEntity>;
     /**
      * 实例方法：记录操作日志
      */
     logOperation(options: ManualLogOptions): Promise<ManualOperationLogEntity>;
     /**
-     * 静态方法：带事务记录
+     * 开始事务
      *
      * @example
      * ```typescript
-     * const txId = await ManualAuditLogService.beginTransaction('user-123', 'John Doe');
+     * const txId = await this.manualAuditLogService.beginTransaction('user-123', 'John Doe');
      *
-     * await ManualAuditLogService.log({
+     * await this.manualAuditLogService.log({
      *   templateKey: 'order.create',
      *   descriptionParams: { orderId: 'order-1' },
      *   transactionId: txId,
      *   autoCreateTransaction: false,
      * });
      *
-     * await ManualAuditLogService.log({
+     * await this.manualAuditLogService.log({
      *   templateKey: 'payment.process',
      *   descriptionParams: { paymentId: 'pay-1' },
      *   transactionId: txId,
      *   autoCreateTransaction: false,
      * });
      *
-     * await ManualAuditLogService.commitTransaction(txId);
+     * await this.manualAuditLogService.commitTransaction(txId);
      * ```
      */
-    static beginTransaction(userId?: string, username?: string): Promise<string>;
+    beginTransaction(userId?: string, username?: string): Promise<string>;
     /**
-     * 静态方法：提交事务
+     * 提交事务
      */
-    static commitTransaction(transactionId: string): Promise<void>;
+    commitTransaction(transactionId: string): Promise<void>;
     /**
-     * 静态方法：回滚事务
+     * 回滚事务
      */
-    static rollbackTransaction(transactionId: string): Promise<void>;
+    rollbackTransaction(transactionId: string): Promise<void>;
     /**
      * 创建事务
      */
-    private createTransaction;
+    createTransaction(userId?: string, username?: string): Promise<string>;
     /**
      * 更新事务状态
      */
-    private updateTransactionStatus;
+    updateTransactionStatus(transactionId: string, status: AuditTransactionStatus): Promise<void>;
     /**
      * 生成事务ID
      */
@@ -120,7 +121,7 @@ export declare class ManualAuditLogService {
      * @example
      * ```typescript
      * // 混合使用多种模式
-     * await ManualAuditLogService.logBatch([
+     * await this.manualAuditLogService.logBatch([
      *   {
      *     templateKey: 'product.update',
      *     descriptionParams: { productId: 'p1', field: 'price' },
@@ -138,11 +139,11 @@ export declare class ManualAuditLogService {
      * ]);
      * ```
      */
-    static logBatch(operations: ManualLogOptions[], sharedTransactionId?: string): Promise<ManualOperationLogEntity[]>;
+    logBatch(operations: ManualLogOptions[], sharedTransactionId?: string): Promise<ManualOperationLogEntity[]>;
     /**
      * 查询操作日志
      */
-    static findLogs(options: {
+    findLogs(options: {
         templateKey?: string;
         userId?: string;
         transactionId?: string;