@nest-omni/core 4.1.3-2 → 4.1.3-20

package/audit/services/index.d.ts

@@ -3,3 +3,6 @@ export * from './audit-strategy.service';
 export * from './entity-audit.service';
 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/services/index.js

@@ -19,3 +19,6 @@ __exportStar(require("./audit-strategy.service"), exports);
 __exportStar(require("./entity-audit.service"), exports);
 __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/services/manual-audit-log.service.d.ts

@@ -2,23 +2,148 @@ 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);
-    static log(options: ManualLogOptions): Promise<ManualOperationLogEntity>;
+    /**
+     * 记录操作日志
+     *
+     * @description
+     * 支持三种记录模式：
+     * 1. 模板键模式：从数据库查找模板
+     * 2. 直接描述模式：直接传入字符串或多语言描述
+     * 3. 内联模板模式：传入多语言模板 + 参数
+     *
+     * @example
+     * // 模式1：模板键模式
+     * await this.manualAuditLogService.log({
+     *   templateKey: 'user.login',
+     *   descriptionParams: {
+     *     username: 'john.doe',
+     *     loginTime: new Date().toISOString(),
+     *   },
+     * });
+     *
+     * @example
+     * // 模式2：直接描述模式（字符串）
+     * await this.manualAuditLogService.log({
+     *   description: '用户登录系统',
+     * });
+     *
+     * @example
+     * // 模式2：直接描述模式（多语言）
+     * await this.manualAuditLogService.log({
+     *   description: {
+     *     zh: '用户登录系统',
+     *     en: 'User logged in',
+     *   },
+     * });
+     *
+     * @example
+     * // 模式3：内联模板模式
+     * await this.manualAuditLogService.log({
+     *   descriptionTemplate: {
+     *     zh: '用户 {username} 在 {time} 登录了系统',
+     *     en: 'User {username} logged in at {time}',
+     *   },
+     *   descriptionParams: {
+     *     username: 'john.doe',
+     *     time: new Date().toISOString(),
+     *   },
+     * });
+     */
+    log(options: ManualLogOptions): Promise<ManualOperationLogEntity>;
+    /**
+     * 实例方法：记录操作日志
+     */
     logOperation(options: ManualLogOptions): Promise<ManualOperationLogEntity>;
-    static beginTransaction(userId?: string, username?: string): Promise<string>;
-    static commitTransaction(transactionId: string): Promise<void>;
-    static rollbackTransaction(transactionId: string): Promise<void>;
-    private createTransaction;
-    private updateTransactionStatus;
+    /**
+     * 开始事务
+     *
+     * @example
+     * ```typescript
+     * const txId = await this.manualAuditLogService.beginTransaction('user-123', 'John Doe');
+     *
+     * await this.manualAuditLogService.log({
+     *   templateKey: 'order.create',
+     *   descriptionParams: { orderId: 'order-1' },
+     *   transactionId: txId,
+     *   autoCreateTransaction: false,
+     * });
+     *
+     * await this.manualAuditLogService.log({
+     *   templateKey: 'payment.process',
+     *   descriptionParams: { paymentId: 'pay-1' },
+     *   transactionId: txId,
+     *   autoCreateTransaction: false,
+     * });
+     *
+     * await this.manualAuditLogService.commitTransaction(txId);
+     * ```
+     */
+    beginTransaction(userId?: string, username?: string): Promise<string>;
+    /**
+     * 提交事务
+     */
+    commitTransaction(transactionId: string): Promise<void>;
+    /**
+     * 回滚事务
+     */
+    rollbackTransaction(transactionId: string): Promise<void>;
+    /**
+     * 创建事务
+     */
+    createTransaction(userId?: string, username?: string): Promise<string>;
+    /**
+     * 更新事务状态
+     */
+    updateTransactionStatus(transactionId: string, status: AuditTransactionStatus): Promise<void>;
+    /**
+     * 生成事务ID
+     */
     private generateTransactionId;
-    static logBatch(operations: ManualLogOptions[], sharedTransactionId?: string): Promise<ManualOperationLogEntity[]>;
-    static findLogs(options: {
+    /**
+     * 批量记录操作日志
+     *
+     * @description
+     * 批量记录多个操作，支持所有三种记录模式
+     *
+     * @example
+     * ```typescript
+     * // 混合使用多种模式
+     * await this.manualAuditLogService.logBatch([
+     *   {
+     *     templateKey: 'product.update',
+     *     descriptionParams: { productId: 'p1', field: 'price' },
+     *   },
+     *   {
+     *     description: '批量更新库存',
+     *   },
+     *   {
+     *     descriptionTemplate: {
+     *       zh: '更新产品 {productId} 的 {field}',
+     *       en: 'Update {field} of product {productId}',
+     *     },
+     *     descriptionParams: { productId: 'p3', field: 'stock' },
+     *   },
+     * ]);
+     * ```
+     */
+    logBatch(operations: ManualLogOptions[], sharedTransactionId?: string): Promise<ManualOperationLogEntity[]>;
+    /**
+     * 查询操作日志
+     */
+    findLogs(options: {
         templateKey?: string;
         userId?: string;
         transactionId?: string;

package/audit/services/manual-audit-log.service.js

@@ -20,7 +20,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var ManualAuditLogService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ManualAuditLogService = void 0;
 const common_1 = require("@nestjs/common");
@@ -30,46 +29,109 @@ const entities_1 = require("../entities");
 const audit_context_service_1 = require("./audit-context.service");
 const enums_1 = require("../enums");
 const crypto_1 = require("crypto");
-let ManualAuditLogService = ManualAuditLogService_1 = class ManualAuditLogService {
+/**
+ * 手动审计日志服务
+ *
+ * 提供标准的依赖注入方式记录操作日志
+ * @deprecated 静态方法已废弃,请使用依赖注入方式
+ */
+let ManualAuditLogService = class ManualAuditLogService {
     constructor(manualLogRepository, transactionRepository, contextService, dataSource) {
         this.manualLogRepository = manualLogRepository;
         this.transactionRepository = transactionRepository;
         this.contextService = contextService;
         this.dataSource = dataSource;
-        ManualAuditLogService_1.instance = this;
     }
-    static log(options) {
+    /**
+     * 记录操作日志
+     *
+     * @description
+     * 支持三种记录模式：
+     * 1. 模板键模式：从数据库查找模板
+     * 2. 直接描述模式：直接传入字符串或多语言描述
+     * 3. 内联模板模式：传入多语言模板 + 参数
+     *
+     * @example
+     * // 模式1：模板键模式
+     * await this.manualAuditLogService.log({
+     *   templateKey: 'user.login',
+     *   descriptionParams: {
+     *     username: 'john.doe',
+     *     loginTime: new Date().toISOString(),
+     *   },
+     * });
+     *
+     * @example
+     * // 模式2：直接描述模式（字符串）
+     * await this.manualAuditLogService.log({
+     *   description: '用户登录系统',
+     * });
+     *
+     * @example
+     * // 模式2：直接描述模式（多语言）
+     * await this.manualAuditLogService.log({
+     *   description: {
+     *     zh: '用户登录系统',
+     *     en: 'User logged in',
+     *   },
+     * });
+     *
+     * @example
+     * // 模式3：内联模板模式
+     * await this.manualAuditLogService.log({
+     *   descriptionTemplate: {
+     *     zh: '用户 {username} 在 {time} 登录了系统',
+     *     en: 'User {username} logged in at {time}',
+     *   },
+     *   descriptionParams: {
+     *     username: 'john.doe',
+     *     time: new Date().toISOString(),
+     *   },
+     * });
+     */
+    log(options) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!ManualAuditLogService_1.instance) {
-                throw new Error('ManualAuditLogService is not initialized. Make sure AuditModule is imported.');
-            }
-            return ManualAuditLogService_1.instance.logOperation(options);
+            return this.logOperation(options);
         });
     }
+    /**
+     * 实例方法：记录操作日志
+     */
     logOperation(options) {
         return __awaiter(this, void 0, void 0, function* () {
             const { templateKey, description, descriptionTemplate, descriptionParams, userId, username, requestIp, rollbackActions, transactionId, autoCreateTransaction = true, } = options;
+            // 验证参数：至少提供一种模式
             if (!templateKey && !description && !descriptionTemplate) {
                 throw new Error('ManualAuditLogService.log() requires one of: templateKey, description, or descriptionTemplate');
             }
+            // 验证参数冲突
             const modeCount = [templateKey, description, descriptionTemplate].filter(Boolean).length;
             if (modeCount > 1) {
                 throw new Error('ManualAuditLogService.log() accepts only one mode: use either templateKey, description, or descriptionTemplate');
             }
+            // 获取当前上下文（如果有）
             const context = yield this.contextService.getCurrentContext();
+            // 合并用户信息（优先使用传入的参数）
             const finalUserId = userId || context.userId || 'system';
             const finalUsername = username || context.username || 'system';
             const finalRequestIp = requestIp || context.requestIp || 'unknown';
+            // 生成或使用事务ID
             let finalTransactionId = transactionId || context.transactionId;
             if (!finalTransactionId && autoCreateTransaction) {
+                // 自动创建事务
                 finalTransactionId = yield this.createTransaction(finalUserId, finalUsername);
             }
+            // 创建手动操作日志
             const manualLog = this.manualLogRepository.create({
                 transactionId: finalTransactionId,
+                // 模式1: 模板键模式
                 operationTemplateKey: templateKey || null,
                 descriptionParams: descriptionParams || null,
+                // 模式2: 直接描���模式
                 directDescription: description || null,
+                // 模式3: 内联模板模式
                 inlineTemplate: descriptionTemplate || null,
+                // 通用字段
                 userId: finalUserId,
                 username: finalUsername,
                 requestIp: finalRequestIp,
@@ -78,30 +140,54 @@ let ManualAuditLogService = ManualAuditLogService_1 = class ManualAuditLogServic
             return this.manualLogRepository.save(manualLog);
         });
     }
-    static beginTransaction(userId, username) {
+    /**
+     * 开始事务
+     *
+     * @example
+     * ```typescript
+     * const txId = await this.manualAuditLogService.beginTransaction('user-123', 'John Doe');
+     *
+     * await this.manualAuditLogService.log({
+     *   templateKey: 'order.create',
+     *   descriptionParams: { orderId: 'order-1' },
+     *   transactionId: txId,
+     *   autoCreateTransaction: false,
+     * });
+     *
+     * await this.manualAuditLogService.log({
+     *   templateKey: 'payment.process',
+     *   descriptionParams: { paymentId: 'pay-1' },
+     *   transactionId: txId,
+     *   autoCreateTransaction: false,
+     * });
+     *
+     * await this.manualAuditLogService.commitTransaction(txId);
+     * ```
+     */
+    beginTransaction(userId, username) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!ManualAuditLogService_1.instance) {
-                throw new Error('ManualAuditLogService is not initialized');
-            }
-            return ManualAuditLogService_1.instance.createTransaction(userId, username);
+            return this.createTransaction(userId, username);
         });
     }
-    static commitTransaction(transactionId) {
+    /**
+     * 提交事务
+     */
+    commitTransaction(transactionId) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!ManualAuditLogService_1.instance) {
-                throw new Error('ManualAuditLogService is not initialized');
-            }
-            yield ManualAuditLogService_1.instance.updateTransactionStatus(transactionId, enums_1.TransactionStatus.COMMITTED);
+            yield this.updateTransactionStatus(transactionId, enums_1.AuditTransactionStatus.COMMITTED);
         });
     }
-    static rollbackTransaction(transactionId) {
+    /**
+     * 回滚事务
+     */
+    rollbackTransaction(transactionId) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!ManualAuditLogService_1.instance) {
-                throw new Error('ManualAuditLogService is not initialized');
-            }
-            yield ManualAuditLogService_1.instance.updateTransactionStatus(transactionId, enums_1.TransactionStatus.ROLLED_BACK);
+            yield this.updateTransactionStatus(transactionId, enums_1.AuditTransactionStatus.ROLLED_BACK);
         });
     }
+    /**
+     * 创建事务
+     */
     createTransaction(userId, username) {
         return __awaiter(this, void 0, void 0, function* () {
             const context = yield this.contextService.getCurrentContext();
@@ -110,46 +196,77 @@ let ManualAuditLogService = ManualAuditLogService_1 = class ManualAuditLogServic
                 userId: userId || context.userId || 'system',
                 username: username || context.username || 'system',
                 requestIp: context.requestIp || 'unknown',
-                status: enums_1.TransactionStatus.PENDING,
+                status: enums_1.AuditTransactionStatus.PENDING,
                 entities: [],
             });
             const saved = yield this.transactionRepository.save(transaction);
             return saved.id;
         });
     }
+    /**
+     * 更新事务状态
+     */
     updateTransactionStatus(transactionId, status) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.transactionRepository.update({ id: transactionId }, { status });
         });
     }
+    /**
+     * 生成事务ID
+     */
     generateTransactionId() {
         return `txn-${Date.now()}-${(0, crypto_1.randomBytes)(8).toString('hex')}`;
     }
-    static logBatch(operations, sharedTransactionId) {
+    /**
+     * 批量记录操作日志
+     *
+     * @description
+     * 批量记录多个操作，支持所有三种记录模式
+     *
+     * @example
+     * ```typescript
+     * // 混合使用多种模式
+     * await this.manualAuditLogService.logBatch([
+     *   {
+     *     templateKey: 'product.update',
+     *     descriptionParams: { productId: 'p1', field: 'price' },
+     *   },
+     *   {
+     *     description: '批量更新库存',
+     *   },
+     *   {
+     *     descriptionTemplate: {
+     *       zh: '更新产品 {productId} 的 {field}',
+     *       en: 'Update {field} of product {productId}',
+     *     },
+     *     descriptionParams: { productId: 'p3', field: 'stock' },
+     *   },
+     * ]);
+     * ```
+     */
+    logBatch(operations, sharedTransactionId) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!ManualAuditLogService_1.instance) {
-                throw new Error('ManualAuditLogService is not initialized');
-            }
-            const transactionId = sharedTransactionId ||
-                (yield ManualAuditLogService_1.instance.createTransaction());
+            // 创建共享事务ID
+            const transactionId = sharedTransactionId || (yield this.createTransaction());
             const results = [];
             for (const operation of operations) {
-                const result = yield ManualAuditLogService_1.instance.logOperation(Object.assign(Object.assign({}, operation), { transactionId, autoCreateTransaction: false }));
+                const result = yield this.logOperation(Object.assign(Object.assign({}, operation), { transactionId, autoCreateTransaction: false }));
                 results.push(result);
             }
+            // 自动提交事务（如果是自动创建的）
             if (!sharedTransactionId) {
-                yield ManualAuditLogService_1.instance.updateTransactionStatus(transactionId, enums_1.TransactionStatus.COMMITTED);
+                yield this.updateTransactionStatus(transactionId, enums_1.AuditTransactionStatus.COMMITTED);
             }
             return results;
         });
     }
-    static findLogs(options) {
+    /**
+     * 查询操作日志
+     */
+    findLogs(options) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!ManualAuditLogService_1.instance) {
-                throw new Error('ManualAuditLogService is not initialized');
-            }
             const { templateKey, userId, transactionId, startTime, endTime, limit = 100 } = options;
-            const query = ManualAuditLogService_1.instance.manualLogRepository
+            const query = this.manualLogRepository
                 .createQueryBuilder('log')
                 .orderBy('log.createdAt', 'DESC')
                 .take(limit);
@@ -173,10 +290,10 @@ let ManualAuditLogService = ManualAuditLogService_1 = class ManualAuditLogServic
     }
 };
 exports.ManualAuditLogService = ManualAuditLogService;
-exports.ManualAuditLogService = ManualAuditLogService = ManualAuditLogService_1 = __decorate([
+exports.ManualAuditLogService = ManualAuditLogService = __decorate([
     (0, common_1.Injectable)(),
-    __param(0, (0, typeorm_1.InjectRepository)(entities_1.ManualOperationLogEntity, 'audit')),
-    __param(1, (0, typeorm_1.InjectRepository)(entities_1.EntityTransactionEntity, 'audit')),
+    __param(0, (0, typeorm_1.InjectRepository)(entities_1.ManualOperationLogEntity)),
+    __param(1, (0, typeorm_1.InjectRepository)(entities_1.EntityTransactionEntity)),
     __metadata("design:paramtypes", [typeorm_2.Repository,
         typeorm_2.Repository,
         audit_context_service_1.AuditContextService,

package/audit/services/multi-database.service.d.ts

@@ -1,10 +1,17 @@
-import { DataSource } from 'typeorm';
 import { ModuleRef } from '@nestjs/core';
+/**
+ * 多数据库连接管理服务
+ */
 export declare class MultiDatabaseService {
     private readonly moduleRef;
     private readonly config?;
     constructor(moduleRef: ModuleRef, config?: any);
-    getDataSource(connectionName?: string): Promise<DataSource>;
+    /**
+     * 获取所有监听的数据库连接
+     */
     getMonitoredConnections(): string[];
+    /**
+     * 获取审计日志存储的数据库连接
+     */
     getAuditConnection(): string;
 }

package/audit/services/multi-database.service.js

@@ -11,40 +11,28 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MultiDatabaseService = void 0;
 const common_1 = require("@nestjs/common");
-const typeorm_1 = require("@nestjs/typeorm");
 const core_1 = require("@nestjs/core");
+/**
+ * 多数据库连接管理服务
+ */
 let MultiDatabaseService = class MultiDatabaseService {
     constructor(moduleRef, config) {
         this.moduleRef = moduleRef;
         this.config = config;
     }
-    getDataSource() {
-        return __awaiter(this, arguments, void 0, function* (connectionName = 'default') {
-            try {
-                const dataSource = this.moduleRef.get((0, typeorm_1.getDataSourceToken)(connectionName), { strict: false });
-                return dataSource;
-            }
-            catch (error) {
-                throw new Error(`Failed to get DataSource for connection: ${connectionName}`);
-            }
-        });
-    }
+    /**
+     * 获取所有监听的数据库连接
+     */
     getMonitoredConnections() {
         var _a, _b;
         return ((_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.connections) === null || _b === void 0 ? void 0 : _b.monitored) || ['default'];
     }
+    /**
+     * 获取审计日志存储的数据库连接
+     */
     getAuditConnection() {
         var _a, _b;
         return ((_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.connections) === null || _b === void 0 ? void 0 : _b.audit) || 'default';

package/audit/services/operation-description.service.d.ts

@@ -1,21 +1,90 @@
 import { Repository } from 'typeorm';
 import { OperationTemplateEntity, EntityTransactionEntity, EntityAuditLogEntity, ManualOperationLogEntity } from '../entities';
 import { ChangeDetail, TransactionDescription } from '../interfaces';
+import { CacheService } from '../../cache';
+/**
+ * 操作描述服务
+ * 负责根据模板和参数动态生成多语言描述
+ */
 export declare class OperationDescriptionService {
     private readonly templateRepository;
     private readonly transactionRepository;
     private readonly auditLogRepository;
     private readonly manualOperationRepository;
-    private templateCache;
-    constructor(templateRepository: Repository<OperationTemplateEntity>, transactionRepository: Repository<EntityTransactionEntity>, auditLogRepository: Repository<EntityAuditLogEntity>, manualOperationRepository: Repository<ManualOperationLogEntity>);
+    private readonly cacheService;
+    private readonly CACHE_NAMESPACE;
+    private readonly CACHE_TTL;
+    constructor(templateRepository: Repository<OperationTemplateEntity>, transactionRepository: Repository<EntityTransactionEntity>, auditLogRepository: Repository<EntityAuditLogEntity>, manualOperationRepository: Repository<ManualOperationLogEntity>, cacheService: CacheService);
+    /**
+     * 动态生成操作名称
+     * @param templateKey 模板键
+     * @param language 语言
+     * @returns 操作名称
+     */
     generateOperationName(templateKey: string, language?: string): Promise<string>;
+    /**
+     * 动态生成操作描述
+     * @param templateKey 模板键
+     * @param descriptionParams 描述参数
+     * @param language 语言
+     * @returns 描述文本
+     */
     generateDescription(templateKey: string, descriptionParams: Record<string, any>, language?: string): Promise<string>;
+    /**
+     * 动态生成变更详情
+     * @param changeDetails 变更详情列表
+     * @param language 语言
+     * @returns 格式化的变更详情
+     */
     generateChangeDetails(changeDetails: ChangeDetail[], language?: string): Promise<any[]>;
+    /**
+     * 获取事务描述（包含所有变更）
+     * @param transactionId 事务ID
+     * @param language 语言
+     * @returns 事务描述对象
+     */
     getTransactionDescription(transactionId: string, language?: string): Promise<TransactionDescription>;
+    /**
+     * 批量获取事务描述
+     * @param transactionIds 事务ID列表
+     * @param language 语言
+     * @returns 事务描述映射
+     */
     batchGetTransactionDescriptions(transactionIds: string[], language?: string): Promise<Record<string, TransactionDescription>>;
+    /**
+     * 填充模板
+     * @param template 模板字符串
+     * @param params 参数
+     * @returns 填充后的字符串
+     */
     private fillTemplate;
+    /**
+     * 格式化显示值
+     * @param value 原始值
+     * @param displayValue 显示值
+     * @returns 格式化后的值
+     */
     private formatDisplayValue;
+    /**
+     * 获取操作模板（使用统一缓存服务）
+     * @param templateKey 模板键
+     * @returns 操作模板
+     */
     private getOperationTemplate;
+    /**
+     * 获取模板字符串（仅返回模板文本，不填充参数）
+     * @param templateKey 模板键
+     * @param language 语言
+     * @returns 模板字符串
+     */
+    getTemplate(templateKey: string, language?: string): Promise<string | null>;
+    /**
+     * 清除模板缓存
+     */
     clearTemplateCache(): void;
+    /**
+     * 预加载模板到缓存
+     * @param templateKeys 模板键列表
+     */
     preloadTemplates(templateKeys: string[]): Promise<void>;
 }