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

package/dist/service/FileCenterService.js

@@ -20,7 +20,7 @@ const CurdMixService_1 = require("./curd/CurdMixService");
 const keys_1 = require("../libs/crud-pro/models/keys");
 const bizmodels_1 = require("../models/bizmodels");
 const BaseService_1 = require("./base/BaseService");
-const SystemTables_1 = require("../models/SystemTables");
+const global_config_1 = require("../libs/global-config/global-config");
 function getSuffix(s) {
     if (s) {
         const indexOf = s.lastIndexOf('.');
@@ -93,12 +93,13 @@ class FileDB {
         this.curdMixService = curdMixService;
     }
     async getFileInfo(fileKey) {
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
         const condition = { file_key: fileKey };
         const cfgModel = {
             sqlTable: 'sys_file',
             sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_ONE,
-            sqlDatabase: SystemTables_1.SystemDbName,
-            sqlDdType: SystemTables_1.SystemDbType,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
             validateCfg: {
                 'condition.file_key': [keys_1.KeysOfValidators.REQUIRED, keys_1.KeysOfValidators.STRING],
             },
@@ -107,11 +108,12 @@ class FileDB {
         return res.getOneObj();
     }
     async saveFileInfo(fileInfo) {
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
         const cfgModel = {
             sqlTable: 'sys_file',
             sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_INSERT,
-            sqlDatabase: SystemTables_1.SystemDbName,
-            sqlDdType: SystemTables_1.SystemDbType,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
         };
         return await this.curdMixService.executeCrudByCfg({
             data: fileInfo,
@@ -121,20 +123,22 @@ class FileDB {
         }, cfgModel);
     }
     async saveAssetsLog(fileInfo) {
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
         const cfgModel = {
             sqlTable: 'sys_assets_log',
             sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_INSERT,
-            sqlDatabase: SystemTables_1.SystemDbName,
-            sqlDdType: SystemTables_1.SystemDbType,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
         };
         return await this.curdMixService.executeCrudByCfg({ data: fileInfo }, cfgModel);
     }
     async deleteFileInfo(id) {
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
         const cfgModel = {
             sqlTable: 'sys_file',
             sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_DELETE,
-            sqlDatabase: SystemTables_1.SystemDbName,
-            sqlDdType: SystemTables_1.SystemDbType,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
             validateCfg: {
                 'condition.id': [keys_1.KeysOfValidators.REQUIRED, keys_1.KeysOfValidators.NUMBER],
             },

package/dist/service/SysConfigService.js

@@ -15,18 +15,20 @@ const keys_1 = require("../libs/crud-pro/models/keys");
 const SystemTables_1 = require("../models/SystemTables");
 const BaseService_1 = require("./base/BaseService");
 const CurdProService_1 = require("./curd/CurdProService");
+const global_config_1 = require("../libs/global-config/global-config");
 let SysConfigService = class SysConfigService extends BaseService_1.BaseService {
     async getSysConfigOne(config_code) {
         if (!config_code) {
             throw new Error('[getSysConfigOne] config_code required');
         }
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
         const res1 = await this.curdProService.executeCrudByCfg({
             condition: { config_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,
         });
         return res1.getOneObj();
     }

package/dist/service/UserAccountService.js

@@ -18,20 +18,22 @@ const functions_1 = require("../libs/utils/functions");
 const exceptions_1 = require("../libs/crud-pro/exceptions");
 const SystemTables_1 = require("../models/SystemTables");
 const common_dto_1 = require("../libs/utils/common-dto");
+const global_config_1 = require("../libs/global-config/global-config");
 let UserAccountService = class UserAccountService {
     /**
      * 查询用户: 根据loginName查询
      * @param loginName
      */
     async queryUserAccountByLoginName(loginName) {
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
         const query = await this.curdMixService.executeCrudByCfg({
             condition: { login_name: loginName },
         }, {
             method: 'UserAccountService.queryUserAccountByLoginName',
             sqlTable: SystemTables_1.SystemTables.sys_user_account,
             sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_ONE,
-            sqlDatabase: SystemTables_1.SystemDbName,
-            sqlDdType: SystemTables_1.SystemDbType,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
         });
         const { row } = query.getResModel();
         return row;
@@ -45,6 +47,7 @@ let UserAccountService = class UserAccountService {
         if (!accountIdList || accountIdList.length === 0) {
             return [];
         }
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
         const accountIds = accountIdList.map(userId => {
             return `${userId}`;
         });
@@ -52,8 +55,8 @@ let UserAccountService = class UserAccountService {
             method: 'UserAccountService.queryAccountBasicInfoByIds',
             sqlTable: SystemTables_1.SystemTables.sys_user_account,
             sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY,
-            sqlDatabase: SystemTables_1.SystemDbName,
-            sqlDdType: SystemTables_1.SystemDbType,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
         };
         const reqJson = {
             columns: columns,
@@ -75,6 +78,7 @@ let UserAccountService = class UserAccountService {
         if (!loginName) {
             throw new exceptions_1.CommonException(exceptions_1.Exceptions.OTHER_EXCEPTION, 'loginName不存在');
         }
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
         const pwd_salt = (0, functions_1.createUniqueId)();
         const pwd_md5 = md5(unsaltedPwd + pwd_salt);
         const res1 = await this.curdMixService.executeCrudByCfg({
@@ -83,8 +87,8 @@ let UserAccountService = class UserAccountService {
         }, {
             sqlTable: SystemTables_1.SystemTables.sys_user_account,
             sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE,
-            sqlDatabase: SystemTables_1.SystemDbName,
-            sqlDdType: SystemTables_1.SystemDbType,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
         });
         return common_dto_1.CommonResult.successRes(res1.getResModel());
     }

package/dist/service/UserSessionService.js

@@ -14,6 +14,7 @@ const core_1 = require("@midwayjs/core");
 const functions_1 = require("../libs/utils/functions");
 const userSession_1 = require("../models/userSession");
 const RedisCacheService_1 = require("./base/RedisCacheService");
+const RedisKeys_1 = require("../models/RedisKeys");
 function pickUserAvatar(avatar) {
     if (!avatar) {
         return null;
@@ -41,7 +42,7 @@ function pickUserAvatar(avatar) {
 }
 const SESSION_KEEP_TIME_SECOND = 3600 * 24 * 30;
 const toCacheKey = (sessionId) => {
-    return `UserSession@@${sessionId}`;
+    return `${RedisKeys_1.RedisKeys.USER_SESSION_PREFIX}${sessionId}`;
 };
 let UserSessionService = class UserSessionService {
     async saveUserSession(sessionInfo) {

package/dist/service/VisitStatService.d.ts

@@ -1,6 +1,6 @@
 import { Context } from '@midwayjs/koa';
 import { IScheduleService } from '../interface';
-import { BaseService } from "./base/BaseService";
+import { BaseService } from './base/BaseService';
 export declare class VisitStatService extends BaseService implements IScheduleService {
     protected ctx: Context;
     private curdProService;

package/dist/service/VisitStatService.js

@@ -17,6 +17,8 @@ const SystemTables_1 = require("../models/SystemTables");
 const keys_1 = require("../libs/crud-pro/models/keys");
 const bizmodels_1 = require("../models/bizmodels");
 const common_dto_1 = require("../libs/utils/common-dto");
+const global_config_1 = require("../libs/global-config/global-config");
+const RedisKeys_1 = require("../models/RedisKeys");
 // 3天 的秒数
 const EXPIRE_TIME = 3 * 24 * 60 * 60;
 const STAT_TYPES = {
@@ -27,25 +29,26 @@ const STAT_TYPES = {
 let VisitStatService = class VisitStatService extends BaseService_1.BaseService {
     async runBySchedule() {
         const hours = new Date().getHours();
-        this.logInfo("[VisitStatService] runBySchedule called, hours = " + hours);
+        this.logInfo('[VisitStatService] runBySchedule called, hours = ' + hours);
         return this.flushVisitStatToDB();
     }
     async flushVisitStatToDB() {
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
         //  统计昨天的数据。
         const stat_date = new Date(Date.now() - 24 * 3600 * 1000).toISOString().split('T')[0];
-        const lockKey = `vs_lock_${stat_date}`;
+        const lockKey = `${RedisKeys_1.RedisKeys.VISIT_STAT_LOCK_PREFIX}${stat_date}`;
         // 每天只能执行一次
         const client = this.redisService;
         const nxRes = await client.set(lockKey, 1, 'EX', EXPIRE_TIME, 'NX');
         if (nxRes !== 'OK') {
-            this.logInfo("[VisitStatService] flushVisitStatToDB 每天只能执行一次 ");
-            return common_dto_1.CommonResult.errorRes("每天只能执行一次");
+            this.logInfo('[VisitStatService] flushVisitStatToDB 每天只能执行一次 ');
+            return common_dto_1.CommonResult.errorRes('每天只能执行一次');
         }
-        this.logInfo("[VisitStatService] flushVisitStatToDB start ");
+        this.logInfo('[VisitStatService] flushVisitStatToDB start ');
         let totalCount = 0;
         let successCount = 0;
         try {
-            const keys = await client.keys(`vs_${stat_date}::*`);
+            const keys = await client.keys(`${RedisKeys_1.RedisKeys.VISIT_STAT_DATE_PREFIX}${stat_date}::*`);
             // `vs_${date}::${req_host}::${resource_type}::${stat_type}::${resource}`;
             totalCount = keys.length;
             for (const key of keys) {
@@ -57,7 +60,7 @@ let VisitStatService = class VisitStatService extends BaseService_1.BaseService
                         const stat_type = parts[3];
                         const stat_resource = parts[4];
                         let stat_count;
-                        if (stat_type === STAT_TYPES.uv_ip || stat_type == STAT_TYPES.uv_uid) {
+                        if (stat_type === STAT_TYPES.uv_ip || stat_type === STAT_TYPES.uv_uid) {
                             stat_count = await client.scard(key);
                         }
                         else {
@@ -70,12 +73,12 @@ let VisitStatService = class VisitStatService extends BaseService_1.BaseService
                                 stat_type,
                                 resource_type,
                                 stat_count,
-                                req_host
-                            }
+                                req_host,
+                            },
                         }, {
                             sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_INSERT,
-                            sqlDatabase: SystemTables_1.SystemDbName,
-                            sqlDdType: SystemTables_1.SystemDbType,
+                            sqlDatabase: SystemDbName,
+                            sqlDbType: SystemDbType,
                             sqlTable: SystemTables_1.SystemTables.sys_visit_stats,
                         });
                         await client.del(key);
@@ -92,7 +95,7 @@ let VisitStatService = class VisitStatService extends BaseService_1.BaseService
             this.logError('[VisitStatService] flushVisitStatToDB', error);
             console.log('[VisitStatService] flushVisitStatToDB', error);
         }
-        this.logInfo("[VisitStatService] flushVisitStatToDB end ");
+        this.logInfo('[VisitStatService] flushVisitStatToDB end ');
         return common_dto_1.CommonResult.successRes({ successCount, totalCount });
     }
     /**
@@ -122,34 +125,24 @@ let VisitStatService = class VisitStatService extends BaseService_1.BaseService
         const client = this.redisService;
         const ip = this.ctx.headers['x-real-ip'];
         const userSession = this.ctx.userSession;
-        const req_host = ((_b = (_a = this.ctx) === null || _a === void 0 ? void 0 : _a.request) === null || _b === void 0 ? void 0 : _b.host) || "null"; // 域名
+        const req_host = ((_b = (_a = this.ctx) === null || _a === void 0 ? void 0 : _a.request) === null || _b === void 0 ? void 0 : _b.host) || 'null'; // 域名
         const date = new Date().toISOString().split('T')[0];
         const toDateResourceKey = (stat_type) => {
-            return `vs_${date}::${req_host}::${resource_type}::${stat_type}::${resource}`;
+            return `${RedisKeys_1.RedisKeys.VISIT_STAT_DATE_PREFIX}${date}::${req_host}::${resource_type}::${stat_type}::${resource}`;
         };
         const pv_key = toDateResourceKey(STAT_TYPES.pv);
         const uv_ip_key = toDateResourceKey(STAT_TYPES.uv_ip);
         const uv_uid_key = toDateResourceKey(STAT_TYPES.uv_uid);
         // 统计 PV
-        await Promise.all([
-            client.incr(pv_key),
-            client.expire(pv_key, EXPIRE_TIME)
-        ]);
+        await Promise.all([client.incr(pv_key), client.expire(pv_key, EXPIRE_TIME)]);
         // IP 访问 UV
-        await Promise.all([
-            client.sadd(uv_ip_key, `${ip}`),
-            client.expire(uv_ip_key, EXPIRE_TIME)
-        ]);
+        await Promise.all([client.sadd(uv_ip_key, `${ip}`), client.expire(uv_ip_key, EXPIRE_TIME)]);
         if (userSession && userSession.isLogin()) {
             const accountId = userSession.getSessionInfo().accountId;
             // 统计 UV
-            await Promise.all([
-                client.sadd(uv_uid_key, accountId),
-                client.expire(uv_uid_key, EXPIRE_TIME)
-            ]);
+            await Promise.all([client.sadd(uv_uid_key, accountId), client.expire(uv_uid_key, EXPIRE_TIME)]);
         }
     }
-    ;
 };
 __decorate([
     (0, core_1.Inject)(),

package/dist/service/WorkbenchService.js

@@ -20,6 +20,7 @@ const exceptions_1 = require("../libs/crud-pro/exceptions");
 const functions_1 = require("../libs/utils/functions");
 const fatcms_request_1 = require("../libs/utils/fatcms-request");
 const MixinUtils_1 = require("../libs/crud-pro/utils/MixinUtils");
+const global_config_1 = require("../libs/global-config/global-config");
 //
 // const lruCache = new LRUCache<string, any>({
 //   max: 500,
@@ -38,14 +39,15 @@ let WorkbenchService = class WorkbenchService extends BaseService_1.BaseService
         await this.getAllWorkbenchInfoMap(true);
     }
     async getAllWorkbenchInfoList(isForceRefresh) {
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
         let listData = lruCache.get(CACHE_KEY_WORKBENCH_LIST);
         if (!listData || isForceRefresh === true) {
             const reqJson = { condition: {}, pageSize: 1000, limit: 1000 };
             const res = await this.curdProService.executeCrudByCfg(reqJson, {
                 sqlTable: SystemTables_1.SystemTables.sys_workbench,
                 sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY,
-                sqlDatabase: SystemTables_1.SystemDbName,
-                sqlDdType: SystemTables_1.SystemDbType,
+                sqlDatabase: SystemDbName,
+                sqlDbType: SystemDbType,
             });
             listData = res.getResRows();
             lruCache.set(CACHE_KEY_WORKBENCH_LIST, listData);

package/dist/service/anyapi/AnyApiService.js

@@ -23,6 +23,7 @@ const MixinUtils_1 = require("../../libs/crud-pro/utils/MixinUtils");
 const WorkbenchService_1 = require("../WorkbenchService");
 const ValidateUtils_1 = require("../../libs/crud-pro/utils/ValidateUtils");
 const ApiBaseService_1 = require("../base/ApiBaseService");
+const global_config_1 = require("../../libs/global-config/global-config");
 const lruCache = new lru_cache_1.LRUCache({
     max: 500,
     ttl: 1000 * 60,
@@ -65,12 +66,13 @@ let AnyApiService = class AnyApiService extends ApiBaseService_1.ApiBaseService
         return anyApi;
     }
     async _getAnyApiMethod(methodCode) {
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
         const res = await this.curdMixService.executeCrudByCfg({ condition: { method: methodCode } }, {
             sqlTable: SystemTables_1.SystemTables.sys_anyapi,
             method: `get_sys_anyapi_${methodCode}`,
             sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_ONE,
-            sqlDatabase: SystemTables_1.SystemDbName,
-            sqlDdType: SystemTables_1.SystemDbType,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
             updateCfg: {},
         });
         const obj = res.getOneObj();

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

@@ -0,0 +1,37 @@
+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
+     * @param updatePartials
+     * @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>;
+    /**
+     * 是否存在新任务
+     * @private
+     */
+    private isExistNewTask;
+}
+export {};

package/dist/service/asyncTask/AsyncTaskRunnerService.js

@@ -0,0 +1,226 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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 = 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");
+const AsyncTaskModel_1 = require("../../models/AsyncTaskModel");
+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");
+const RedisKeys_1 = require("../../models/RedisKeys");
+const END_STATUS_LIST = [AsyncTaskModel_1.SysAsyncTaskStatus.SUCCEEDED, AsyncTaskModel_1.SysAsyncTaskStatus.FAILED, AsyncTaskModel_1.SysAsyncTaskStatus.PART_SUCCEEDED];
+class AsyncTaskRunner {
+    constructor() {
+        this.isBusy = false;
+        this.taskHandlerMap = new Map();
+    }
+    async executeTaskList(taskList) {
+        if (!taskList || taskList.length === 0) {
+            return;
+        }
+        this.isBusy = true;
+        for (let i = 0; i < taskList.length; i++) {
+            const taskElement = taskList[i];
+            taskElement.task_status = AsyncTaskModel_1.SysAsyncTaskStatus.RUNNING;
+            try {
+                // 任务状态的设置在自定义的执行器里面。
+                await this.executeTask(taskElement);
+                // 当前不是终止状态，并且没有异常就设置成成功。
+                if (!END_STATUS_LIST.includes(taskElement.task_status)) {
+                    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, {
+                    task_status: taskElement.task_status,
+                    error_message: taskElement.error_message,
+                });
+            }
+            catch (error) {
+                schedule_1.ANONYMOUS_CONTEXT.getApp().getCoreLogger().error('executeTaskList error', error);
+            }
+        }
+        this.isBusy = false;
+    }
+    async executeTask(taskElement) {
+        const taskType = taskElement.task_type;
+        const taskHandler = this.taskHandlerMap.get(taskType);
+        if (!taskHandler) {
+            throw new Error('TaskHandler not found , taskType = ' + taskType);
+        }
+        const updateTaskStatus = (updatePartials) => {
+            return this.updateTaskStatus(taskElement, updatePartials);
+        };
+        await taskHandler.execute({ task: taskElement, updateTaskStatus });
+    }
+    /**
+     * 更新任务状态或任务进度
+     * @param taskElement
+     * @param updatePartials
+     * @private
+     */
+    async updateTaskStatus(taskElement, updatePartials) {
+        if (!updatePartials) {
+            throw new Error('updatePartials not found');
+        }
+        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 res = await curdProService.executeCrudByCfg({
+                condition: {
+                    id: taskElement.id,
+                },
+                data: updatePartials,
+            }, {
+                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];
+    }
+}
+/**
+ * 业务可以扩展
+ */
+exports.ASYNC_TASK_RUNNER = new AsyncTaskRunner();
+/**
+ * Redis锁
+ */
+const ASYNC_TASK_LOCK = RedisKeys_1.RedisKeys.ASYNC_TASK_LOCK;
+const ASYNC_TASK_RUNTIME_OBJ = {
+    LAST_CHECK_ASYNC_TASK_UPDATE_TIME: 0,
+};
+let AsyncTaskRunnerService = class AsyncTaskRunnerService extends BaseService_1.BaseService {
+    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 queryRes = await this.curdProService.executeCrudByCfg({
+            condition: {
+                task_status: AsyncTaskModel_1.SysAsyncTaskStatus.PENDING,
+                task_type: {
+                    $in: taskTypeList,
+                },
+            },
+            orderBy: 'id+',
+            limit: 10,
+        }, {
+            sqlTable: SystemTables_1.SystemTables.sys_async_tasks,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_PAGE,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
+        });
+        const taskList = queryRes.getResRows();
+        if (taskList.length === 0) {
+            return Promise.resolve();
+        }
+        const taskIds = taskList.map(elem => elem.id).filter(Boolean);
+        // 将状态更新为处理中。防止其它进程重复处理。
+        await this.curdProService.executeCrudByCfg({
+            condition: {
+                id: {
+                    $in: taskIds,
+                },
+            },
+            data: {
+                task_status: AsyncTaskModel_1.SysAsyncTaskStatus.RUNNING,
+            },
+        }, {
+            sqlTable: SystemTables_1.SystemTables.sys_async_tasks,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
+        });
+        // 开始执行。
+        exports.ASYNC_TASK_RUNNER.executeTaskList(taskList).then(() => {
+            console.log('ASYNC_TASK_RUNNER finished taskIds ==> ' + JSON.stringify(taskIds));
+        });
+    }
+    async runBySchedule() {
+        // 1. 当前很忙
+        if (exports.ASYNC_TASK_RUNNER.isBusy) {
+            return Promise.resolve();
+        }
+        // 2. 发现了新任务
+        const isExistNewTask = await this.isExistNewTask();
+        if (!isExistNewTask) {
+            return Promise.resolve();
+        }
+        // 这里的过期时间1分钟即可。fetchPendingTasks函数不可能超过一分钟。
+        // 因为这里只是从数据库中获取一批任务，放到自己的任务队列里。还没触发执行。
+        const lock = await this.redisService.set(ASYNC_TASK_LOCK, 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(ASYNC_TASK_LOCK);
+        return Promise.resolve();
+    }
+    /**
+     * 是否存在新任务
+     * @private
+     */
+    async isExistNewTask() {
+        // 刚启动，没有检查过。
+        if (!ASYNC_TASK_RUNTIME_OBJ.LAST_CHECK_ASYNC_TASK_UPDATE_TIME) {
+            ASYNC_TASK_RUNTIME_OBJ.LAST_CHECK_ASYNC_TASK_UPDATE_TIME = Date.now();
+            return true;
+        }
+        //Redis没有任何内容
+        const updateTime = await this.redisService.get(RedisKeys_1.RedisKeys.ASYNC_TASK_UPDATE_TIME);
+        if (!updateTime) {
+            ASYNC_TASK_RUNTIME_OBJ.LAST_CHECK_ASYNC_TASK_UPDATE_TIME = Date.now();
+            return false;
+        }
+        const updateTimeNumber = Number.parseInt(updateTime, 10);
+        const isExistNewTask = updateTimeNumber > ASYNC_TASK_RUNTIME_OBJ.LAST_CHECK_ASYNC_TASK_UPDATE_TIME;
+        ASYNC_TASK_RUNTIME_OBJ.LAST_CHECK_ASYNC_TASK_UPDATE_TIME = updateTimeNumber;
+        return isExistNewTask;
+    }
+};
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", Object)
+], AsyncTaskRunnerService.prototype, "ctx", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", CurdProService_1.CurdProService)
+], AsyncTaskRunnerService.prototype, "curdProService", void 0);
+AsyncTaskRunnerService = __decorate([
+    (0, core_1.Provide)()
+], AsyncTaskRunnerService);
+exports.AsyncTaskRunnerService = AsyncTaskRunnerService;

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

@@ -0,0 +1,7 @@
+import { Context } from '@midwayjs/koa';
+import { BaseService } from '../../service/base/BaseService';
+export declare class AsyncTaskService extends BaseService {
+    protected ctx: Context;
+    startTask(): Promise<void>;
+    cancelTask(id: number): Promise<void>;
+}

package/dist/service/asyncTask/AsyncTaskService.js

@@ -0,0 +1,34 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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.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");
+const RedisKeys_1 = require("../../models/RedisKeys");
+let AsyncTaskService = class AsyncTaskService extends BaseService_1.BaseService {
+    async startTask() {
+        await this.redisService.set(RedisKeys_1.RedisKeys.ASYNC_TASK_UPDATE_TIME, `${Date.now()}`);
+        (0, schedule_1.runScheduleTaskOnce)(scheduleNames_1.INNER_SCHEDULE_NAMES.asyncTaskRunnerService).then(schedule => {
+            console.log(schedule);
+        });
+    }
+    async cancelTask(id) { }
+};
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", Object)
+], AsyncTaskService.prototype, "ctx", void 0);
+AsyncTaskService = __decorate([
+    (0, core_1.Provide)()
+], AsyncTaskService);
+exports.AsyncTaskService = AsyncTaskService;

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;
 }