midway-fatcms 0.0.1-beta.14 → 0.0.1-beta.17

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,4 +1,4 @@
-import * as koa from '@midwayjs/koa';
-declare function runSchedule(app: koa.Application, serviceList: string[]): Promise<void>;
-declare function startSchedule(app: koa.Application, serviceList: string[]): Promise<void>;
-export { startSchedule, runSchedule };
+import { startScheduleLoop, runScheduleTaskOnce } from './runSchedule';
+import { ANONYMOUS_CONTEXT } from './anonymousContext';
+import { ALL_SCHEDULE_NAMES, SCHEDULE_NAMES } from './scheduleNames';
+export { ALL_SCHEDULE_NAMES, SCHEDULE_NAMES, ANONYMOUS_CONTEXT, startScheduleLoop, runScheduleTaskOnce };

package/dist/schedule/index.js

@@ -1,70 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runSchedule = 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);
-        }
-    }
-}
-exports.runSchedule = runSchedule;
-async function startSchedule(app, serviceList) {
-    await runSchedule(app, serviceList);
-    setInterval(() => {
-        runSchedule(app, serviceList);
-    }, 2 * 60 * 1000);
-}
-exports.startSchedule = startSchedule;
+exports.runScheduleTaskOnce = exports.startScheduleLoop = exports.ANONYMOUS_CONTEXT = exports.SCHEDULE_NAMES = exports.ALL_SCHEDULE_NAMES = void 0;
+const runSchedule_1 = require("./runSchedule");
+Object.defineProperty(exports, "startScheduleLoop", { enumerable: true, get: function () { return runSchedule_1.startScheduleLoop; } });
+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, "ALL_SCHEDULE_NAMES", { enumerable: true, get: function () { return scheduleNames_1.ALL_SCHEDULE_NAMES; } });
+Object.defineProperty(exports, "SCHEDULE_NAMES", { enumerable: true, get: function () { return scheduleNames_1.SCHEDULE_NAMES; } });

package/dist/schedule/runSchedule.d.ts

@@ -0,0 +1,6 @@
+declare function runScheduleTaskOnce(serviceName: string): Promise<{
+    result: any;
+    error: any;
+}>;
+declare function startScheduleLoop(serviceList: string[]): Promise<void>;
+export { startScheduleLoop, runScheduleTaskOnce };

package/dist/schedule/runSchedule.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runScheduleTaskOnce = exports.startScheduleLoop = void 0;
+const anonymousContext_1 = require("./anonymousContext");
+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;
+async function runScheduleServiceList(serviceList) {
+    for (let i = 0; i < serviceList.length; i++) {
+        const serviceName = serviceList[i];
+        try {
+            await runScheduleTaskOnce(serviceName);
+        }
+        catch (e) {
+            anonymousContext_1.ANONYMOUS_CONTEXT.getApp().getCoreLogger().error(`runSchedule error , serviceName = ${serviceName}`, e);
+        }
+    }
+}
+async function startScheduleLoop(serviceList) {
+    await runScheduleServiceList(serviceList);
+    setInterval(() => {
+        runScheduleServiceList(serviceList);
+    }, 2 * 60 * 1000);
+}
+exports.startScheduleLoop = startScheduleLoop;

package/dist/schedule/scheduleNames.d.ts

@@ -0,0 +1,8 @@
+declare const SCHEDULE_NAMES: {
+    proxyApiLoadService: string;
+    workbenchService: string;
+    visitStatService: string;
+    asyncTaskRunnerService: string;
+};
+declare const ALL_SCHEDULE_NAMES: string[];
+export { ALL_SCHEDULE_NAMES, SCHEDULE_NAMES, };

package/dist/schedule/scheduleNames.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCHEDULE_NAMES = exports.ALL_SCHEDULE_NAMES = void 0;
+const SCHEDULE_NAMES = {
+    proxyApiLoadService: 'proxyApiLoadService',
+    workbenchService: 'workbenchService',
+    visitStatService: 'visitStatService',
+    asyncTaskRunnerService: 'asyncTaskRunnerService',
+};
+exports.SCHEDULE_NAMES = SCHEDULE_NAMES;
+const ALL_SCHEDULE_NAMES = [
+    SCHEDULE_NAMES.proxyApiLoadService,
+    SCHEDULE_NAMES.workbenchService,
+    SCHEDULE_NAMES.visitStatService,
+    SCHEDULE_NAMES.asyncTaskRunnerService
+];
+exports.ALL_SCHEDULE_NAMES = ALL_SCHEDULE_NAMES;

package/dist/service/asyncTask/AsyncTaskRunnerService.d.ts

@@ -1,8 +1,31 @@
 import { Context } from '@midwayjs/koa';
 import { BaseService } from "../../service/base/BaseService";
 import { IScheduleService } from "../../interface";
+import { ISysAsyncTaskHandler, SysAsyncTaskEntity } from "../../models/AsyncTaskModel";
+declare class AsyncTaskRunner {
+    isBusy: boolean;
+    taskHandlerMap: Map<string, ISysAsyncTaskHandler>;
+    executeTaskList(taskList: SysAsyncTaskEntity[]): Promise<void>;
+    private executeTask;
+    /**
+     * 更新任务状态或任务进度
+     * @param taskElement
+     * @private
+     */
+    private updateTaskStatus;
+    /**
+     * 获取当前进程可以处理的任务类型。
+     */
+    getHandlerTaskTypeList(): string[];
+}
+/**
+ * 业务可以扩展
+ */
+export declare const ASYNC_TASK_RUNNER: AsyncTaskRunner;
 export declare class AsyncTaskRunnerService extends BaseService implements IScheduleService {
     protected ctx: Context;
     private curdProService;
+    fetchPendingTasks(): Promise<void>;
     runBySchedule(): Promise<void>;
 }
+export {};

package/dist/service/asyncTask/AsyncTaskRunnerService.js

@@ -9,7 +9,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncTaskRunnerService = void 0;
+exports.AsyncTaskRunnerService = exports.ASYNC_TASK_RUNNER = void 0;
 const core_1 = require("@midwayjs/core");
 const BaseService_1 = require("../../service/base/BaseService");
 const CurdProService_1 = require("../../service/curd/CurdProService");
@@ -18,6 +18,7 @@ const global_config_1 = require("../../libs/global-config/global-config");
 const SystemTables_1 = require("../../models/SystemTables");
 const keys_1 = require("../../libs/crud-pro/models/keys");
 const errorToString_1 = require("../../libs/utils/errorToString");
+const schedule_1 = require("../../schedule");
 class AsyncTaskRunner {
     constructor() {
         this.isBusy = false;
@@ -31,14 +32,21 @@ class AsyncTaskRunner {
         for (let i = 0; i < taskList.length; i++) {
             const taskElement = taskList[i];
             try {
+                // 任务状态的设置在自定义的执行器里面。
                 await this.executeTask(taskElement);
-                taskElement.task_status = AsyncTaskModel_1.SysAsyncTaskStatus.SUCCEEDED;
             }
             catch (error) {
                 taskElement.task_status = AsyncTaskModel_1.SysAsyncTaskStatus.FAILED;
                 taskElement.error_message = (0, errorToString_1.errorToString)(error);
             }
+            try {
+                await this.updateTaskStatus(taskElement);
+            }
+            catch (error) {
+                schedule_1.ANONYMOUS_CONTEXT.getApp().getCoreLogger().error("executeTaskList error", error);
+            }
         }
+        this.isBusy = false;
     }
     async executeTask(taskElement) {
         const taskType = taskElement.task_type;
@@ -46,25 +54,68 @@ class AsyncTaskRunner {
         if (!taskHandler) {
             throw new Error('TaskHandler not found , taskType = ' + taskType);
         }
-        await taskHandler.execute({ task: taskElement });
+        const updateTaskStatus = () => {
+            return this.updateTaskStatus(taskElement);
+        };
+        await taskHandler.execute({ task: taskElement, updateTaskStatus });
+    }
+    /**
+     * 更新任务状态或任务进度
+     * @param taskElement
+     * @private
+     */
+    async updateTaskStatus(taskElement) {
+        return await schedule_1.ANONYMOUS_CONTEXT.runServiceAtAnonymousContext(async (ctx) => {
+            const curdProService = await ctx.requestContext.getAsync("curdProService");
+            const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
+            const { id, ...otherTaskProps } = taskElement;
+            const res = await curdProService.executeCrudByCfg({
+                condition: {
+                    id: id
+                },
+                data: otherTaskProps
+            }, {
+                sqlTable: SystemTables_1.SystemTables.sys_async_tasks,
+                sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE,
+                sqlDatabase: SystemDbName,
+                sqlDbType: SystemDbType,
+            });
+            return res.getResModel().affected;
+        });
+    }
+    /**
+     * 获取当前进程可以处理的任务类型。
+     */
+    getHandlerTaskTypeList() {
+        const keys = this.taskHandlerMap.keys();
+        return [...keys];
     }
 }
-const ASYNC_TASK_RUNNER = new AsyncTaskRunner();
+/**
+ * 业务可以扩展
+ */
+exports.ASYNC_TASK_RUNNER = new AsyncTaskRunner();
+/**
+ * Redis锁
+ */
 const LOCK_KEY_ASYNC_TASK_RUNNER = "LOCK_KEY_ASYNC_TASK_RUNNER";
 let AsyncTaskRunnerService = class AsyncTaskRunnerService extends BaseService_1.BaseService {
-    async runBySchedule() {
-        if (ASYNC_TASK_RUNNER.isBusy) {
-            return Promise.resolve();
-        }
-        const lock = await this.redisService.set(LOCK_KEY_ASYNC_TASK_RUNNER, 1, "EX", 3600, "NX");
-        if (lock !== 'OK') {
+    async fetchPendingTasks() {
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
+        // 只获取本进程能够处理的任务类型。
+        const taskTypeList = exports.ASYNC_TASK_RUNNER.getHandlerTaskTypeList();
+        if (taskTypeList.length === 0) {
             return Promise.resolve();
         }
-        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
+        // 查询等待处理的任务。
         const queryRes = await this.curdProService.executeCrudByCfg({
             condition: {
-                task_status: AsyncTaskModel_1.SysAsyncTaskStatus.PENDING
+                task_status: AsyncTaskModel_1.SysAsyncTaskStatus.PENDING,
+                task_type: {
+                    "$in": taskTypeList
+                }
             },
+            orderBy: 'id+',
             limit: 10
         }, {
             sqlTable: SystemTables_1.SystemTables.sys_async_tasks,
@@ -77,6 +128,7 @@ let AsyncTaskRunnerService = class AsyncTaskRunnerService extends BaseService_1.
             return Promise.resolve();
         }
         const taskIds = taskList.map(elem => elem.id).filter(Boolean);
+        // 将状态更新为处理中。防止其它进程重复处理。
         await this.curdProService.executeCrudByCfg({
             condition: {
                 id: {
@@ -92,7 +144,28 @@ let AsyncTaskRunnerService = class AsyncTaskRunnerService extends BaseService_1.
             sqlDatabase: SystemDbName,
             sqlDbType: SystemDbType,
         });
-        ASYNC_TASK_RUNNER.executeTaskList(taskList);
+        // 开始执行。
+        exports.ASYNC_TASK_RUNNER.executeTaskList(taskList).then(() => {
+            console.log("ASYNC_TASK_RUNNER finished taskIds ==> " + JSON.stringify(taskIds));
+        });
+    }
+    async runBySchedule() {
+        if (exports.ASYNC_TASK_RUNNER.isBusy) {
+            return Promise.resolve();
+        }
+        // 这里的过期时间1分钟即可。fetchPendingTasks函数不可能超过一分钟。
+        // 因为这里只是从数据库中获取一批任务，放到自己的任务队列里。还没触发执行。
+        const lock = await this.redisService.set(LOCK_KEY_ASYNC_TASK_RUNNER, 1, "EX", 60, "NX");
+        if (lock !== 'OK') {
+            return Promise.resolve();
+        }
+        try {
+            await this.fetchPendingTasks();
+        }
+        catch (e) {
+            console.error("fetchPendingTasks error", (0, errorToString_1.errorToString)(e));
+        }
+        await this.redisService.del(LOCK_KEY_ASYNC_TASK_RUNNER);
         return Promise.resolve();
     }
 };

package/dist/service/asyncTask/AsyncTaskService.js

@@ -13,9 +13,10 @@ exports.AsyncTaskService = void 0;
 const core_1 = require("@midwayjs/core");
 const BaseService_1 = require("../../service/base/BaseService");
 const schedule_1 = require("../../schedule");
+const scheduleNames_1 = require("../../schedule/scheduleNames");
 let AsyncTaskService = class AsyncTaskService extends BaseService_1.BaseService {
     async startTask() {
-        (0, schedule_1.runSchedule)(this.app, ['asyncTaskRunnerService']).then(schedule => {
+        (0, schedule_1.runScheduleTaskOnce)(scheduleNames_1.SCHEDULE_NAMES.asyncTaskRunnerService).then(schedule => {
             console.log(schedule);
         });
     }

package/dist/service/crudstd/CrudStdService.d.ts

@@ -47,4 +47,5 @@ export declare class CrudStdService extends ApiBaseService {
      */
     getParsedCrudStdAppInfo(appCode: string): Promise<ICrudStdAppInfo>;
     private hasOperationPerm;
+    private fixDataFieldTypeBySqlTableField;
 }

package/dist/service/crudstd/CrudStdService.js

@@ -22,6 +22,7 @@ const _ = require("lodash");
 const ApiBaseService_1 = require("../base/ApiBaseService");
 const DatabaseName_1 = require("../../libs/crud-pro/utils/DatabaseName");
 const global_config_1 = require("../../libs/global-config/global-config");
+const MixinUtils_1 = require("../../libs/crud-pro/utils/MixinUtils");
 exports.SPECIAL_SETTING_KEY = {
     QUERY_LIST: 'QUERY_LIST',
     QUERY_ONE: 'QUERY_ONE',
@@ -54,6 +55,8 @@ let CrudStdService = class CrudStdService extends ApiBaseService_1.ApiBaseServic
         }
         // 根据用户配置，设置关联查询的数据信息。
         await this.crudStdRelationService.addCfgModelColumnsRelation(cfgModel, appInfo);
+        // 根据表结构的数据类型，修正数据类型
+        await this.fixDataFieldTypeBySqlTableField(params, cfgModel, appInfo, { dbType, dbName });
         // 业务系统自定义的修改cfgModel
         await global_config_1.GLOBAL_STATIC_CONFIG.getConfig().bizUpdateCfgModelForCrudStd(params, cfgModel, appInfo, this.ctx);
         return await this.curdMixService.executeCrudByCfg(params, cfgModel);
@@ -163,6 +166,30 @@ let CrudStdService = class CrudStdService extends ApiBaseService_1.ApiBaseServic
         }
         return true; // 无需鉴权
     }
+    async fixDataFieldTypeBySqlTableField(params, cfgModel, appInfo, arg3) {
+        const tableFields = _.get(appInfo, 'stdCrudCfgObj.tableFields');
+        const tableFieldMap = MixinUtils_1.MixinUtils.toMap(tableFields, (e) => {
+            return e.fieldIndex;
+        });
+        if (arg3.dbType === keys_1.SqlDbType.postgres) {
+            if (cfgModel.sqlSimpleName === keys_1.KeysOfSimpleSQL.SIMPLE_INSERT || cfgModel.sqlSimpleName === keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE) {
+                const data = params.data || {};
+                const dataKeys = Object.keys(data);
+                for (let index = 0; index < dataKeys.length; index++) {
+                    const dataKey = dataKeys[index];
+                    const dataValue = data[dataKey];
+                    const fieldInfo = tableFieldMap[dataKey];
+                    const fieldType = ('' + _.get(fieldInfo, 'type')).toUpperCase();
+                    if (fieldType === 'ARRAY') {
+                        const dataValueArray = (0, functions_1.parseJsonObject)(dataValue);
+                        if (Array.isArray(dataValueArray)) {
+                            data[dataKey] = `{${dataValueArray.map(v => `"${v}"`).join(',')}}`;
+                        }
+                    }
+                }
+            }
+        }
+    }
 };
 __decorate([
     (0, core_1.Inject)(),

package/dist/service/curd/CrudProQuick.d.ts

@@ -0,0 +1,24 @@
+import { SqlDbType } from "../../libs/crud-pro/models/keys";
+import { IRequestModel } from "../../libs/crud-pro/interfaces";
+import { IRequestCfgModel2 } from "../../models/bizmodels";
+import { CrudPro } from "../../libs/crud-pro/CrudPro";
+import { ResModelAffected, ResModelStandard } from "../../libs/crud-pro/models/ResModel";
+export declare class CrudProQuick {
+    private readonly curdPro;
+    private readonly sqlDbType;
+    private readonly sqlDatabase;
+    private readonly sqlTable?;
+    private baseCfgModel;
+    constructor(curdPro: CrudPro, sqlDatabase: string, sqlDbType: SqlDbType, sqlTable?: string);
+    setBaseCfgModel(baseCfgModel: IRequestCfgModel2): void;
+    private executeCrudByCfg;
+    getOne(reqJson: IRequestModel, sqlTable?: string): Promise<any>;
+    getList(reqJson: IRequestModel, sqlTable?: string): Promise<any[]>;
+    getListPage(reqJson: IRequestModel, sqlTable?: string): Promise<ResModelStandard>;
+    getTotalCount(reqJson: IRequestModel, sqlTable?: string): Promise<number>;
+    insertObject(reqJson: IRequestModel, sqlTable?: string): Promise<ResModelAffected>;
+    updateObject(reqJson: IRequestModel, sqlTable?: string): Promise<ResModelAffected>;
+    insertOrUpdate(reqJson: IRequestModel, sqlTable?: string): Promise<ResModelStandard>;
+    deleteObject(reqJson: IRequestModel, sqlTable?: string): Promise<ResModelAffected>;
+    executeSQL(executeSql: string, args?: any[]): Promise<any>;
+}

package/dist/service/curd/CrudProQuick.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrudProQuick = void 0;
+const keys_1 = require("../../libs/crud-pro/models/keys");
+class CrudProQuick {
+    constructor(curdPro, sqlDatabase, sqlDbType, sqlTable) {
+        this.baseCfgModel = {};
+        this.sqlDatabase = sqlDatabase;
+        this.sqlDbType = sqlDbType;
+        this.curdPro = curdPro;
+        this.sqlTable = sqlTable; // 全局sqlTable为空时，单独调用时就必须传sqlTable参数。
+    }
+    setBaseCfgModel(baseCfgModel) {
+        Object.assign(this.baseCfgModel, baseCfgModel);
+    }
+    async executeCrudByCfg(reqJson, cfgModel2) {
+        const cfgModel = { ...this.baseCfgModel };
+        Object.assign(cfgModel, cfgModel2);
+        cfgModel.method = 'CrudProQuickAnonymous';
+        cfgModel.updateCfg = {};
+        cfgModel.sqlDatabase = this.sqlDatabase;
+        cfgModel.sqlDbType = this.sqlDbType;
+        if (!cfgModel.sqlTable) {
+            cfgModel.sqlTable = this.sqlTable;
+        }
+        if (!cfgModel.sqlTable) {
+            throw new Error('[CrudProQuick] sqlTable not found');
+        }
+        return await this.curdPro.executeCrudByCfg(reqJson, cfgModel);
+    }
+    async getOne(reqJson, sqlTable) {
+        const cfgModel = {
+            sqlTable,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_ONE,
+        };
+        const res = await this.executeCrudByCfg(reqJson, cfgModel);
+        return res.getOneObj();
+    }
+    async getList(reqJson, sqlTable) {
+        const cfgModel = {
+            sqlTable,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY,
+        };
+        const res = await this.executeCrudByCfg(reqJson, cfgModel);
+        return res.getResRows();
+    }
+    async getListPage(reqJson, sqlTable) {
+        const cfgModel = {
+            sqlTable,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_PAGE,
+        };
+        const res = await this.executeCrudByCfg(reqJson, cfgModel);
+        return res.getResModel(); // 因为它有2个返回值
+    }
+    async getTotalCount(reqJson, sqlTable) {
+        const cfgModel = {
+            sqlTable,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_COUNT,
+        };
+        const res = await this.executeCrudByCfg(reqJson, cfgModel);
+        return res.getResModel().total_count;
+    }
+    async insertObject(reqJson, sqlTable) {
+        const cfgModel = {
+            sqlTable,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_INSERT,
+        };
+        const res = await this.executeCrudByCfg(reqJson, cfgModel);
+        return res.getResModel().affected;
+    }
+    async updateObject(reqJson, sqlTable) {
+        const cfgModel = {
+            sqlTable,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE,
+        };
+        const res = await this.executeCrudByCfg(reqJson, cfgModel);
+        return res.getResModel().affected;
+    }
+    async insertOrUpdate(reqJson, sqlTable) {
+        const cfgModel = {
+            sqlTable,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_INSERT_OR_UPDATE,
+        };
+        const res = await this.executeCrudByCfg(reqJson, cfgModel);
+        return res.getResModel(); // 因为它有三个返回值
+    }
+    async deleteObject(reqJson, sqlTable) {
+        const cfgModel = {
+            sqlTable,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_DELETE,
+        };
+        const res = await this.executeCrudByCfg(reqJson, cfgModel);
+        return res.getResModel().affected;
+    }
+    async executeSQL(executeSql, args) {
+        const sqlCfgModel = {
+            executeSql: executeSql,
+            executeSqlArgs: args,
+            sqlDatabase: this.sqlDatabase,
+            sqlDbType: this.sqlDbType,
+        };
+        return await this.curdPro.executeSQL(sqlCfgModel);
+    }
+}
+exports.CrudProQuick = CrudProQuick;

package/dist/service/curd/CurdMixByLinkToCustomService.d.ts

@@ -1,7 +1,7 @@
 import { Context } from '@midwayjs/koa';
 import { CurdProService } from './CurdProService';
 import { ExecuteContext, IExecuteContextHandler } from '../../libs/crud-pro/models/ExecuteContext';
-import { RedisCacheService } from "../base/RedisCacheService";
+import { RedisCacheService } from '../base/RedisCacheService';
 export declare class CurdMixByLinkToCustomService implements IExecuteContextHandler {
     protected ctx: Context;
     protected curdProService: CurdProService;
@@ -13,10 +13,19 @@ export declare class CurdMixByLinkToCustomService implements IExecuteContextHand
      * code形如：mysql_________fatcms~~~sys_perm_role~~~role_code,role_name,xxx_name
      * code形如：fatcms~~~sys_perm_role~~~role_code,role_name,xxx_name
      * code形如：fatcms~~~sys_perm_role~~~id,*
+     * code形如：GET_BY_CRUD_METHOD~~~GetActiveLineEnum~~~id,*
+     * code形如：GET_BY_CRUD_METHOD~~~GetActiveLineEnum~~~id,name
      * 【数据库】~~~【表名】~~~【value】,【label】，【style】
      * @param code
      * @private
      */
     private queryInfoByLinkToCustomImpl;
+    /**
+     *
+     * @param code
+     * code形如：GET_BY_CRUD_METHOD~~~GetActiveLineEnum~~~id,*
+     * code形如：GET_BY_CRUD_METHOD~~~GetActiveLineEnum~~~id,name
+     */
+    private queryInfoByLinkToCustomByCrudMethod;
     private loadInfoByLinkToCustomMap;
 }