midway-fatcms 0.0.1-beta.2 → 0.0.1-beta.20

package/dist/libs/utils/fatcms-request.js

@@ -84,7 +84,7 @@ async function isCsrfTokenValid(ctx) {
         const depryptToken = await crypto_utils_1.privateAES.time_decrypt_base64_utf8(fatcmscsrftoken);
         if (depryptToken) {
             const num = Number(depryptToken);
-            if (num && ((num + 6 * 3600 * 1000) > Date.now())) {
+            if (num && num + 6 * 3600 * 1000 > Date.now()) {
                 return true;
             }
         }
@@ -98,7 +98,7 @@ exports.isCsrfTokenValid = isCsrfTokenValid;
 async function assertCsrfToken(ctx) {
     const isOK = await isCsrfTokenValid(ctx);
     if (!isOK) {
-        throw new exceptions_1.CommonException("ASSERT_CSRF_TOKEN_ERROR", "CSRF_TOKEN 验证失败");
+        throw new exceptions_1.CommonException('ASSERT_CSRF_TOKEN_ERROR', 'CSRF_TOKEN 验证失败');
     }
 }
 exports.assertCsrfToken = assertCsrfToken;

package/dist/middleware/forbidden.middleware.js

@@ -9,24 +9,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ForbiddenMiddleware = void 0;
 const core_1 = require("@midwayjs/core");
 // 一些爬虫/漏洞分析工具会来请求这玩意。
-const blackEqualList = [
-    '/config.json',
-    '/backend/.env',
-    '/application.yml',
-    '/db.ini',
-    '/.well-known/security.txt',
-];
-const blackPrefixList = [
-    '/.aws/',
-    '/.git/',
-    '/.svn/',
-    '/.env/',
-    '/src/',
-    '/var/logs/',
-    '/var/log/',
-    '/cgi-bin/',
-    '/php-cgi/',
-];
+const blackEqualList = ['/config.json', '/backend/.env', '/application.yml', '/db.ini', '/.well-known/security.txt'];
+const blackPrefixList = ['/.aws/', '/.git/', '/.svn/', '/.env/', '/src/', '/var/logs/', '/var/log/', '/cgi-bin/', '/php-cgi/'];
 /**
  * 针对一些路径禁止访问。避免一些爬虫抓取网站内容，实际上这里枚举的路径，本身就是不存在的。只是为了提前拦截，为了服务器性能考虑。
  */
@@ -55,9 +39,9 @@ let ForbiddenMiddleware = class ForbiddenMiddleware {
     }
     resolve() {
         return async (ctx, next) => {
-            ctx.set({ "content-type": "text/html; charset=utf-8" });
+            ctx.set({ 'content-type': 'text/html; charset=utf-8' });
             ctx.status = 404;
-            ctx.body = "404！404！404！重要的事情说三遍！";
+            ctx.body = '404！404！404！重要的事情说三遍！';
         };
     }
     static getName() {

package/dist/middleware/global.middleware.js

@@ -186,13 +186,20 @@ async function trackRequest(ctx) {
         console.error('trackRequestError', e);
     }
 }
+const excludePathPrefix = ['/ns/static/', '/ns/api/helpers'];
 /**
  * 全局中间件
  */
 let GlobalMiddleware = class GlobalMiddleware {
     match(ctx) {
         const path = ctx.path;
-        return !(path.startsWith('/ns/static/'));
+        for (let i = 0; i < excludePathPrefix.length; i++) {
+            const excludePathPrefix1 = excludePathPrefix[i];
+            if (path.startsWith(excludePathPrefix1)) {
+                return false;
+            }
+        }
+        return true;
     }
     resolve() {
         return async (ctx, next) => {

package/dist/models/AsyncTaskModel.d.ts

@@ -0,0 +1,69 @@
+export interface SysAsyncTaskEntity {
+    id: number;
+    task_uuid: string;
+    task_name: string;
+    task_description: string | null;
+    task_type: string;
+    task_status: SysAsyncTaskStatus;
+    input_params: any;
+    output_result: any | null;
+    input_file_path: string | null;
+    input_file_format: SysAsyncFileFormat | null;
+    input_file_size: number | null;
+    output_file_path: string | null;
+    output_file_format: SysAsyncFileFormat | null;
+    output_file_size: number | null;
+    input_total_records: number | null;
+    output_total_records: number | null;
+    processed_records: number;
+    progress: number;
+    error_message: string | null;
+    error_records: any | null;
+    created_by: string | null;
+    priority: number;
+    retry_count: number;
+    max_retries: number;
+    parent_task_id: number | null;
+    created_at: Date;
+    started_at: Date | null;
+    updated_at: Date;
+    expired_at: Date | null;
+    completed_at: Date | null;
+    created_user_session: string;
+}
+export declare type SysAsyncTaskPartial = Partial<SysAsyncTaskEntity>;
+export declare enum SysAsyncTaskStatus {
+    PENDING = "PENDING",
+    RUNNING = "RUNNING",
+    SUCCEEDED = "SUCCEEDED",
+    PART_SUCCEEDED = "PART_SUCCEEDED",
+    FAILED = "FAILED",
+    CANCELLED = "CANCELLED",
+    PAUSED = "PAUSED"
+}
+export declare enum SysAsyncFileFormat {
+    XLSX = "xlsx",
+    CSV = "csv",
+    JSON = "json",
+    PDF = "pdf",
+    TXT = "txt",
+    XML = "xml",
+    ZIP = "zip",
+    HTML = "html",
+    PNG = "png",
+    JPG = "jpg"
+}
+export interface ISysAsyncTaskHandler {
+    execute(asyncTaskContext: SysAsyncTaskContext): Promise<void>;
+}
+export interface SysAsyncTaskContext {
+    task: SysAsyncTaskEntity;
+    updateTaskStatus: (sysAsyncTaskPartial: SysAsyncTaskPartial) => any;
+}
+export interface SysAsyncTaskHandlerConfig {
+    taskType: string;
+    handler: ISysAsyncTaskHandler;
+    maxRetries?: number;
+    priority?: number;
+    expireSeconds?: number;
+}

package/dist/models/AsyncTaskModel.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SysAsyncFileFormat = exports.SysAsyncTaskStatus = void 0;
+var SysAsyncTaskStatus;
+(function (SysAsyncTaskStatus) {
+    SysAsyncTaskStatus["PENDING"] = "PENDING";
+    SysAsyncTaskStatus["RUNNING"] = "RUNNING";
+    SysAsyncTaskStatus["SUCCEEDED"] = "SUCCEEDED";
+    SysAsyncTaskStatus["PART_SUCCEEDED"] = "PART_SUCCEEDED";
+    SysAsyncTaskStatus["FAILED"] = "FAILED";
+    SysAsyncTaskStatus["CANCELLED"] = "CANCELLED";
+    SysAsyncTaskStatus["PAUSED"] = "PAUSED";
+})(SysAsyncTaskStatus = exports.SysAsyncTaskStatus || (exports.SysAsyncTaskStatus = {}));
+var SysAsyncFileFormat;
+(function (SysAsyncFileFormat) {
+    SysAsyncFileFormat["XLSX"] = "xlsx";
+    SysAsyncFileFormat["CSV"] = "csv";
+    SysAsyncFileFormat["JSON"] = "json";
+    SysAsyncFileFormat["PDF"] = "pdf";
+    SysAsyncFileFormat["TXT"] = "txt";
+    SysAsyncFileFormat["XML"] = "xml";
+    SysAsyncFileFormat["ZIP"] = "zip";
+    SysAsyncFileFormat["HTML"] = "html";
+    SysAsyncFileFormat["PNG"] = "png";
+    SysAsyncFileFormat["JPG"] = "jpg";
+})(SysAsyncFileFormat = exports.SysAsyncFileFormat || (exports.SysAsyncFileFormat = {}));

package/dist/models/RedisKeys.d.ts

@@ -0,0 +1,8 @@
+declare const RedisKeys: {
+    ASYNC_TASK_LOCK: string;
+    ASYNC_TASK_UPDATE_TIME: string;
+    USER_SESSION_PREFIX: string;
+    VISIT_STAT_LOCK_PREFIX: string;
+    VISIT_STAT_DATE_PREFIX: string;
+};
+export { RedisKeys };

package/dist/models/RedisKeys.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisKeys = void 0;
+const RedisKeys = {
+    ASYNC_TASK_LOCK: "FatAsyncTaskLock",
+    ASYNC_TASK_UPDATE_TIME: "FatAsyncTaskUpdateTime",
+    USER_SESSION_PREFIX: "FatUserSession_",
+    VISIT_STAT_LOCK_PREFIX: "FatVsLock_",
+    VISIT_STAT_DATE_PREFIX: "FatVsDate_",
+};
+exports.RedisKeys = RedisKeys;

package/dist/models/SystemTables.d.ts

@@ -1,4 +1,3 @@
-import { SqlDbType } from "../libs/crud-pro/models/keys";
 export declare const SystemTables: {
     sys_workbench: string;
     sys_user_account: string;
@@ -21,7 +20,6 @@ export declare const SystemTables: {
     sys_anyapi: string;
     sys_proxyapi: string;
     sys_visit_stats: string;
+    sys_async_tasks: string;
 };
-export declare const SystemDbName = "fatcms";
-export declare const SystemDbType = SqlDbType.mysql;
 export declare const SystemDevOpsWorkbench = "devops";

package/dist/models/SystemTables.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SystemDevOpsWorkbench = exports.SystemDbType = exports.SystemDbName = exports.SystemTables = void 0;
-const keys_1 = require("../libs/crud-pro/models/keys");
+exports.SystemDevOpsWorkbench = exports.SystemTables = void 0;
 exports.SystemTables = {
     sys_workbench: 'sys_workbench',
     sys_user_account: 'sys_user_account',
@@ -24,7 +23,6 @@ exports.SystemTables = {
     sys_anyapi: 'sys_anyapi',
     sys_proxyapi: 'sys_proxyapi',
     sys_visit_stats: 'sys_visit_stats',
+    sys_async_tasks: 'sys_async_tasks',
 };
-exports.SystemDbName = 'fatcms';
-exports.SystemDbType = keys_1.SqlDbType.mysql;
 exports.SystemDevOpsWorkbench = 'devops';

package/dist/schedule/anonymousContext.d.ts

@@ -0,0 +1,13 @@
+import * as koa from '@midwayjs/koa';
+export declare type RunServiceAtAnonymousContextRunner = (ctx: koa.IMidwayKoaContext) => any;
+declare class AnonymousContext {
+    private app;
+    setApp(app: koa.Application): void;
+    getApp(): koa.IMidwayKoaApplication;
+    runServiceAtAnonymousContext(runner: RunServiceAtAnonymousContextRunner): Promise<{
+        result: any;
+        error: any;
+    }>;
+}
+declare const ANONYMOUS_CONTEXT: AnonymousContext;
+export { ANONYMOUS_CONTEXT };

package/dist/schedule/anonymousContext.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ANONYMOUS_CONTEXT = void 0;
+const contextLogger_1 = require("../models/contextLogger");
+const Transaction_1 = require("../libs/crud-pro/models/Transaction");
+const userSession_1 = require("../models/userSession");
+const anonymousUserInfo = {
+    nickName: 'anonymous_user',
+    avatar: '',
+    roleCodes: [],
+    functionCodes: [],
+    loginName: 'anonymous_user',
+    sessionId: '',
+    accountId: '',
+    workbenchCode: '',
+    accountType: userSession_1.SYS_ACCOUNT_TYPE,
+};
+const anonymousWorkbenchInfo = {
+    id: 0,
+    workbench_code: 'anonymous_workbench',
+    workbench_name: 'anonymous_workbench',
+    workbench_domain: 'anonymous_workbench',
+    workbench_desc: 'anonymous_workbench',
+    html_content: 'anonymous_workbench',
+    status: 1,
+    workbench_type: 0,
+};
+class AnonymousContext {
+    setApp(app) {
+        this.app = app;
+    }
+    getApp() {
+        return this.app;
+    }
+    async runServiceAtAnonymousContext(runner) {
+        const app = this.app;
+        const ctx = app.createAnonymousContext();
+        ctx.app = app;
+        ctx.contextLogger = new contextLogger_1.ContextLogger(ctx);
+        ctx.transaction = new Transaction_1.Transaction();
+        ctx.userSession = new userSession_1.UserSessionInfo(anonymousUserInfo, true);
+        ctx.workbenchInfo = anonymousWorkbenchInfo;
+        let result = null;
+        let error = null;
+        try {
+            result = await runner(ctx);
+        }
+        catch (e) {
+            error = e;
+            ctx.logger.error(`runServiceAtAnonymousContext error `, e);
+        }
+        finally {
+            await ctx.transaction.releaseTx();
+        }
+        return { result: result, error: error };
+    }
+}
+const ANONYMOUS_CONTEXT = new AnonymousContext();
+exports.ANONYMOUS_CONTEXT = ANONYMOUS_CONTEXT;

package/dist/schedule/index.d.ts

@@ -1,3 +1,4 @@
-import * as koa from '@midwayjs/koa';
-declare function startSchedule(app: koa.Application, serviceList: string[]): Promise<void>;
-export { startSchedule };
+import { SCHEDULE_QUEUE, runScheduleTaskOnce } from './runSchedule';
+import { ANONYMOUS_CONTEXT } from './anonymousContext';
+import { INNER_SCHEDULE_INTERVAL } from './scheduleNames';
+export { INNER_SCHEDULE_INTERVAL, ANONYMOUS_CONTEXT, SCHEDULE_QUEUE, runScheduleTaskOnce };

package/dist/schedule/index.js

@@ -1,69 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.startSchedule = void 0;
-const contextLogger_1 = require("../models/contextLogger");
-const Transaction_1 = require("../libs/crud-pro/models/Transaction");
-const userSession_1 = require("../models/userSession");
-const scheduleUserInfo = {
-    nickName: 'schedule_user',
-    avatar: '',
-    roleCodes: [],
-    functionCodes: [],
-    loginName: 'schedule_user',
-    sessionId: '',
-    accountId: '',
-    workbenchCode: '',
-    accountType: userSession_1.SYS_ACCOUNT_TYPE,
-};
-const scheduleWorkbenchInfo = {
-    id: 0,
-    workbench_code: 'schedule_workbench',
-    workbench_name: 'schedule_workbench',
-    workbench_domain: 'schedule_workbench',
-    workbench_desc: 'schedule_workbench',
-    html_content: 'schedule_workbench',
-    status: 1,
-    workbench_type: 0,
-};
-async function runScheduleService(app, serviceName) {
-    const ctx = app.createAnonymousContext();
-    ctx.app = app;
-    ctx.contextLogger = new contextLogger_1.ContextLogger(ctx);
-    ctx.transaction = new Transaction_1.Transaction();
-    ctx.userSession = new userSession_1.UserSessionInfo(scheduleUserInfo, true);
-    ctx.workbenchInfo = scheduleWorkbenchInfo;
-    try {
-        const serviceObject = await ctx.requestContext.getAsync(serviceName);
-        if (serviceObject && serviceObject.runBySchedule) {
-            await serviceObject.runBySchedule();
-        }
-        else {
-            ctx.logger.error(`runSchedule error , serviceName = ${serviceName}, 没有找到服务`);
-        }
-    }
-    catch (e) {
-        ctx.logger.error(`runSchedule error , serviceName = ${serviceName}`, e);
-    }
-    finally {
-        await ctx.transaction.releaseTx();
-    }
-}
-async function runSchedule(app, serviceList) {
-    for (let i = 0; i < serviceList.length; i++) {
-        const serviceName = serviceList[i];
-        try {
-            await runScheduleService(app, serviceName);
-        }
-        catch (e) {
-            const ctx = app.createAnonymousContext();
-            ctx.logger.error(`runSchedule error , serviceName = ${serviceName}`, e);
-        }
-    }
-}
-async function startSchedule(app, serviceList) {
-    await runSchedule(app, serviceList);
-    setInterval(() => {
-        runSchedule(app, serviceList);
-    }, 2 * 60 * 1000);
-}
-exports.startSchedule = startSchedule;
+exports.runScheduleTaskOnce = exports.SCHEDULE_QUEUE = exports.ANONYMOUS_CONTEXT = exports.INNER_SCHEDULE_INTERVAL = void 0;
+const runSchedule_1 = require("./runSchedule");
+Object.defineProperty(exports, "SCHEDULE_QUEUE", { enumerable: true, get: function () { return runSchedule_1.SCHEDULE_QUEUE; } });
+Object.defineProperty(exports, "runScheduleTaskOnce", { enumerable: true, get: function () { return runSchedule_1.runScheduleTaskOnce; } });
+const anonymousContext_1 = require("./anonymousContext");
+Object.defineProperty(exports, "ANONYMOUS_CONTEXT", { enumerable: true, get: function () { return anonymousContext_1.ANONYMOUS_CONTEXT; } });
+const scheduleNames_1 = require("./scheduleNames");
+Object.defineProperty(exports, "INNER_SCHEDULE_INTERVAL", { enumerable: true, get: function () { return scheduleNames_1.INNER_SCHEDULE_INTERVAL; } });

package/dist/schedule/runSchedule.d.ts

@@ -0,0 +1,15 @@
+declare function runScheduleTaskOnce(serviceName: string): Promise<{
+    result: any;
+    error: any;
+}>;
+declare class ScheduleQueue {
+    private scheduleIntervalMap;
+    setScheduleTask(serviceName: string, intervalTime: number): void;
+    removeScheduleTask(serviceName: string): void;
+    private isAlreadyTimeToExecute;
+    private runScheduleTaskOnceCheckTime;
+    private runScheduleServiceList;
+    startScheduleLoop(): Promise<void>;
+}
+declare const SCHEDULE_QUEUE: ScheduleQueue;
+export { SCHEDULE_QUEUE, runScheduleTaskOnce };

package/dist/schedule/runSchedule.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runScheduleTaskOnce = exports.SCHEDULE_QUEUE = void 0;
+const anonymousContext_1 = require("./anonymousContext");
+// 上次执行时间
+const lastExecuteTimeMap = {};
+const DEFAULT_SCHEDULE_INTERVAL = 2 * 60 * 1000;
+async function runScheduleTaskOnce(serviceName) {
+    return await anonymousContext_1.ANONYMOUS_CONTEXT.runServiceAtAnonymousContext(async (ctx) => {
+        const serviceObject = await ctx.requestContext.getAsync(serviceName);
+        if (serviceObject && serviceObject.runBySchedule) {
+            await serviceObject.runBySchedule();
+        }
+        else {
+            ctx.logger.error(`runSchedule error , serviceName = ${serviceName}, 没有找到服务`);
+        }
+    });
+}
+exports.runScheduleTaskOnce = runScheduleTaskOnce;
+class ScheduleQueue {
+    constructor() {
+        this.scheduleIntervalMap = new Map();
+    }
+    setScheduleTask(serviceName, intervalTime) {
+        this.scheduleIntervalMap.set(serviceName, intervalTime);
+    }
+    removeScheduleTask(serviceName) {
+        this.scheduleIntervalMap.delete(serviceName);
+    }
+    isAlreadyTimeToExecute(serviceName) {
+        if (!lastExecuteTimeMap[serviceName]) {
+            return true; // 可以执行
+        }
+        const intervalTime1 = this.scheduleIntervalMap.get(serviceName);
+        const intervalTime = intervalTime1 || DEFAULT_SCHEDULE_INTERVAL; // 时间间隔
+        const lastExecuteTime = lastExecuteTimeMap[serviceName];
+        return (Date.now() - lastExecuteTime) >= intervalTime;
+    }
+    async runScheduleTaskOnceCheckTime(serviceName) {
+        // 还没有到可以执行时间
+        if (!this.isAlreadyTimeToExecute(serviceName)) {
+            return;
+        }
+        lastExecuteTimeMap[serviceName] = Date.now();
+        await runScheduleTaskOnce(serviceName);
+    }
+    async runScheduleServiceList() {
+        const serviceListKeys = this.scheduleIntervalMap.keys();
+        const serviceList = [...serviceListKeys];
+        for (let i = 0; i < serviceList.length; i++) {
+            const serviceName = serviceList[i];
+            try {
+                await this.runScheduleTaskOnceCheckTime(serviceName);
+            }
+            catch (e) {
+                anonymousContext_1.ANONYMOUS_CONTEXT.getApp().getCoreLogger().error(`runSchedule error , serviceName = ${serviceName}`, e);
+            }
+        }
+    }
+    async startScheduleLoop() {
+        await this.runScheduleServiceList();
+        setInterval(() => {
+            this.runScheduleServiceList();
+        }, 1000); // 最少1秒执行一次
+    }
+}
+const SCHEDULE_QUEUE = new ScheduleQueue();
+exports.SCHEDULE_QUEUE = SCHEDULE_QUEUE;

package/dist/schedule/scheduleNames.d.ts

@@ -0,0 +1,13 @@
+declare const INNER_SCHEDULE_INTERVAL: {
+    proxyApiLoadService: number;
+    workbenchService: number;
+    visitStatService: number;
+    asyncTaskRunnerService: number;
+};
+declare const INNER_SCHEDULE_NAMES: {
+    proxyApiLoadService: string;
+    workbenchService: string;
+    visitStatService: string;
+    asyncTaskRunnerService: string;
+};
+export { INNER_SCHEDULE_INTERVAL, INNER_SCHEDULE_NAMES };

package/dist/schedule/scheduleNames.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INNER_SCHEDULE_NAMES = exports.INNER_SCHEDULE_INTERVAL = void 0;
+const INNER_SCHEDULE_INTERVAL = {
+    proxyApiLoadService: 2 * 60 * 1000,
+    workbenchService: 60 * 1000,
+    visitStatService: 10 * 60 * 1000,
+    asyncTaskRunnerService: 1000, // 1s可以执行
+};
+exports.INNER_SCHEDULE_INTERVAL = INNER_SCHEDULE_INTERVAL;
+const INNER_SCHEDULE_NAMES = {
+    proxyApiLoadService: 'proxyApiLoadService',
+    workbenchService: 'workbenchService',
+    visitStatService: "visitStatService",
+    asyncTaskRunnerService: "asyncTaskRunnerService",
+};
+exports.INNER_SCHEDULE_NAMES = INNER_SCHEDULE_NAMES;

package/dist/service/AuthService.js

@@ -22,6 +22,7 @@ const UserSessionService_1 = require("./UserSessionService");
 const common_dto_1 = require("../libs/utils/common-dto");
 const fatcms_request_1 = require("../libs/utils/fatcms-request");
 const exceptions_1 = require("../libs/crud-pro/exceptions");
+const global_config_1 = require("../libs/global-config/global-config");
 let AuthService = class AuthService {
     /**
      * 明文密码转unsaltedPwd密码
@@ -116,7 +117,7 @@ let AuthService = class AuthService {
             sessionId,
             accountId,
             workbenchCode,
-            accountType: userSession_1.SYS_ACCOUNT_TYPE
+            accountType: userSession_1.SYS_ACCOUNT_TYPE,
         };
         await this.userSessionService.saveUserSession(sessionInfo);
         return {
@@ -171,14 +172,15 @@ let AuthService = class AuthService {
      * @private
      */
     async queryUserRoleCodeList(accountId) {
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
         const res = await this.curdMixService.executeCrudByCfg({
             condition: { account_id: accountId },
             limit: 10000,
         }, {
             sqlTable: SystemTables_1.SystemTables.sys_perm_user_role,
             sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY,
-            sqlDatabase: SystemTables_1.SystemDbName,
-            sqlDdType: SystemTables_1.SystemDbType,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
         });
         const rows = res.getResModel().rows || [];
         const roleCodes = rows.map(({ role_code }) => {
@@ -195,14 +197,15 @@ let AuthService = class AuthService {
         if (!roleCodeList || roleCodeList.length === 0) {
             return [];
         }
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
         const res = await this.curdMixService.executeCrudByCfg({
             condition: { role_code: { $in: roleCodeList } },
             limit: 10000,
         }, {
             sqlTable: SystemTables_1.SystemTables.sys_perm_role_func,
             sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY,
-            sqlDatabase: SystemTables_1.SystemDbName,
-            sqlDdType: SystemTables_1.SystemDbType,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
         });
         const rows = res.getResModel().rows || [];
         const funcCodes = rows.map(({ func_code }) => {

package/dist/service/EnumInfoService.js

@@ -18,6 +18,7 @@ const SystemTables_1 = require("../models/SystemTables");
 const parseConfig_1 = require("../libs/utils/parseConfig");
 const RedisCacheService_1 = require("./base/RedisCacheService");
 const CurdMixByLinkToCustomService_1 = require("./curd/CurdMixByLinkToCustomService");
+const global_config_1 = require("../libs/global-config/global-config");
 function filterEmpty(e) {
     return e.label && typeof e.value !== 'undefined';
 }
@@ -70,13 +71,14 @@ let EnumInfoService = class EnumInfoService {
         });
     }
     async queryEnumInfoBySysCfgEnum(code) {
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
         const res1 = await this.curdProService.executeCrudByCfg({
             condition: { config_code: code },
         }, {
             sqlTable: SystemTables_1.SystemTables.sys_configs,
             sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_ONE,
-            sqlDatabase: SystemTables_1.SystemDbName,
-            sqlDdType: SystemTables_1.SystemDbType,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
         });
         const obj = res1.getOneObj();
         if (!obj) {
@@ -86,13 +88,14 @@ let EnumInfoService = class EnumInfoService {
         return rows.map(e => ({ label: e.label, value: e.value, children: e.children })).filter(filterEmpty);
     }
     async queryEnumInfoItemByDict(code) {
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
         const res1 = await this.curdProService.executeCrudByCfg({
             condition: { dict_code: code },
         }, {
             sqlTable: SystemTables_1.SystemTables.sys_data_dict_item,
             sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY,
-            sqlDatabase: SystemTables_1.SystemDbName,
-            sqlDdType: SystemTables_1.SystemDbType,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
         });
         const obj = res1.getResRows();
         if (!obj) {