midway-fatcms 0.0.1-beta.64 → 0.0.1-beta.65

package/dist/service/asyncTask/AsyncTaskRunnerService.js

@@ -1,287 +1,287 @@
-"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 moment = require("moment");
-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 functions_1 = require("../../libs/utils/functions");
-const ExportExcelAsyncTaskHandler_1 = require("./handler/ExportExcelAsyncTaskHandler");
-const END_STATUS_LIST = [AsyncTaskModel_1.SysAsyncTaskStatus.PART_SUCCEEDED, AsyncTaskModel_1.SysAsyncTaskStatus.SUCCEEDED, AsyncTaskModel_1.SysAsyncTaskStatus.FAILED, AsyncTaskModel_1.SysAsyncTaskStatus.CANCELLED, AsyncTaskModel_1.SysAsyncTaskStatus.PAUSED];
-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 {
-                // 1. 更新当前这个任务的状态
-                await this.updateTaskStatus(taskElement, {
-                    task_status: taskElement.task_status,
-                    started_at: (0, functions_1.getCurrentFullMoment)(),
-                    updated_at: (0, functions_1.getCurrentFullMoment)(),
-                });
-                // 任务状态的设置在自定义的执行器里面。
-                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 {
-                // 2. 更新当前这个任务的状态
-                await this.updateTaskStatus(taskElement, {
-                    task_status: taskElement.task_status,
-                    error_message: taskElement.error_message,
-                    updated_at: (0, functions_1.getCurrentFullMoment)(),
-                    completed_at: (0, functions_1.getCurrentFullMoment)(),
-                });
-            }
-            catch (error) {
-                schedule_1.ANONYMOUS_CONTEXT.getApp().getCoreLogger().error('[AsyncTaskRunner] 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();
-            // 一定要有一个更新时间字段
-            updatePartials.updated_at = (0, functions_1.getCurrentFullMoment)();
-            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();
-//内置的异步任务处理器：EXCEL导出
-exports.ASYNC_TASK_RUNNER.taskHandlerMap.set('EXCEL_EXPORT', new ExportExcelAsyncTaskHandler_1.ExportExcelAsyncTaskHandler());
-/**
- * Redis锁
- */
-const ASYNC_TASK_LOCK = RedisKeys_1.RedisKeys.ASYNC_TASK_LOCK;
-const ASYNC_TASK_TIMEOUT_LOCK = RedisKeys_1.RedisKeys.ASYNC_TASK_TIMEOUT_LOCK;
-/**
- * 上次检查异步任务的时间点
- */
-const ASYNC_TASK_RUNTIME_OBJ = {
-    LAST_CHECK_ASYNC_TASK_UPDATE_TIME: 0,
-};
-let AsyncTaskRunnerService = class AsyncTaskRunnerService extends BaseService_1.BaseService {
-    /**
-     * 定时任务执行
-     */
-    async runBySchedule() {
-        await this.runByScheduleForPendingTasks();
-        await this.runByScheduleForTimeoutTasks();
-    }
-    /**
-     * 更新超时的任务状态
-     * @returns
-     */
-    async runByScheduleForTimeoutTasks() {
-        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
-        // 每隔一小时执行一次，即可。
-        const lock = await this.redisService.set(ASYNC_TASK_TIMEOUT_LOCK, 1, 'EX', 60 * 60, 'NX');
-        if (lock !== 'OK') {
-            return Promise.resolve();
-        }
-        const timeoutTime = moment().subtract(24, 'hours').format('YYYY-MM-DD HH:mm:ss.SSS');
-        await this.curdProService.executeCrudByCfg({
-            condition: {
-                task_status: AsyncTaskModel_1.SysAsyncTaskStatus.RUNNING,
-                updated_at: {
-                    $lt: timeoutTime,
-                },
-            },
-            data: {
-                task_status: AsyncTaskModel_1.SysAsyncTaskStatus.FAILED,
-                error_message: '任务超时',
-            },
-        }, {
-            sqlTable: SystemTables_1.SystemTables.sys_async_tasks,
-            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE,
-            sqlDatabase: SystemDbName,
-            sqlDbType: SystemDbType,
-        });
-    }
-    /**
-     * 检查是否有新任务。如果有，就从数据库中获取一批任务，放到自己的任务队列里。
-     * @returns
-     */
-    async runByScheduleForPendingTasks() {
-        // 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('[AsyncTaskRunnerService] fetchPendingTasks error', (0, errorToString_1.errorToString)(e));
-        }
-        await this.redisService.del(ASYNC_TASK_LOCK);
-        return Promise.resolve();
-    }
-    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,
-        });
-        // 开始执行。
-        await exports.ASYNC_TASK_RUNNER.executeTaskList(taskList).then(() => {
-            console.log('[AsyncTaskRunnerService] ASYNC_TASK_RUNNER finished taskIds ==> ' + JSON.stringify(taskIds));
-        });
-    }
-    /**
-     * 是否存在新任务
-     * @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;
+"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 moment = require("moment");
+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 functions_1 = require("../../libs/utils/functions");
+const ExportExcelAsyncTaskHandler_1 = require("./handler/ExportExcelAsyncTaskHandler");
+const END_STATUS_LIST = [AsyncTaskModel_1.SysAsyncTaskStatus.PART_SUCCEEDED, AsyncTaskModel_1.SysAsyncTaskStatus.SUCCEEDED, AsyncTaskModel_1.SysAsyncTaskStatus.FAILED, AsyncTaskModel_1.SysAsyncTaskStatus.CANCELLED, AsyncTaskModel_1.SysAsyncTaskStatus.PAUSED];
+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 {
+                // 1. 更新当前这个任务的状态
+                await this.updateTaskStatus(taskElement, {
+                    task_status: taskElement.task_status,
+                    started_at: (0, functions_1.getCurrentFullMoment)(),
+                    updated_at: (0, functions_1.getCurrentFullMoment)(),
+                });
+                // 任务状态的设置在自定义的执行器里面。
+                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 {
+                // 2. 更新当前这个任务的状态
+                await this.updateTaskStatus(taskElement, {
+                    task_status: taskElement.task_status,
+                    error_message: taskElement.error_message,
+                    updated_at: (0, functions_1.getCurrentFullMoment)(),
+                    completed_at: (0, functions_1.getCurrentFullMoment)(),
+                });
+            }
+            catch (error) {
+                schedule_1.ANONYMOUS_CONTEXT.getApp().getCoreLogger().error('[AsyncTaskRunner] 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();
+            // 一定要有一个更新时间字段
+            updatePartials.updated_at = (0, functions_1.getCurrentFullMoment)();
+            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();
+//内置的异步任务处理器：EXCEL导出
+exports.ASYNC_TASK_RUNNER.taskHandlerMap.set('EXCEL_EXPORT', new ExportExcelAsyncTaskHandler_1.ExportExcelAsyncTaskHandler());
+/**
+ * Redis锁
+ */
+const ASYNC_TASK_LOCK = RedisKeys_1.RedisKeys.ASYNC_TASK_LOCK;
+const ASYNC_TASK_TIMEOUT_LOCK = RedisKeys_1.RedisKeys.ASYNC_TASK_TIMEOUT_LOCK;
+/**
+ * 上次检查异步任务的时间点
+ */
+const ASYNC_TASK_RUNTIME_OBJ = {
+    LAST_CHECK_ASYNC_TASK_UPDATE_TIME: 0,
+};
+let AsyncTaskRunnerService = class AsyncTaskRunnerService extends BaseService_1.BaseService {
+    /**
+     * 定时任务执行
+     */
+    async runBySchedule() {
+        await this.runByScheduleForPendingTasks();
+        await this.runByScheduleForTimeoutTasks();
+    }
+    /**
+     * 更新超时的任务状态
+     * @returns
+     */
+    async runByScheduleForTimeoutTasks() {
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
+        // 每隔一小时执行一次，即可。
+        const lock = await this.redisService.set(ASYNC_TASK_TIMEOUT_LOCK, 1, 'EX', 60 * 60, 'NX');
+        if (lock !== 'OK') {
+            return Promise.resolve();
+        }
+        const timeoutTime = moment().subtract(24, 'hours').format('YYYY-MM-DD HH:mm:ss.SSS');
+        await this.curdProService.executeCrudByCfg({
+            condition: {
+                task_status: AsyncTaskModel_1.SysAsyncTaskStatus.RUNNING,
+                updated_at: {
+                    $lt: timeoutTime,
+                },
+            },
+            data: {
+                task_status: AsyncTaskModel_1.SysAsyncTaskStatus.FAILED,
+                error_message: '任务超时',
+            },
+        }, {
+            sqlTable: SystemTables_1.SystemTables.sys_async_tasks,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_UPDATE,
+            sqlDatabase: SystemDbName,
+            sqlDbType: SystemDbType,
+        });
+    }
+    /**
+     * 检查是否有新任务。如果有，就从数据库中获取一批任务，放到自己的任务队列里。
+     * @returns
+     */
+    async runByScheduleForPendingTasks() {
+        // 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('[AsyncTaskRunnerService] fetchPendingTasks error', (0, errorToString_1.errorToString)(e));
+        }
+        await this.redisService.del(ASYNC_TASK_LOCK);
+        return Promise.resolve();
+    }
+    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,
+        });
+        // 开始执行。
+        await exports.ASYNC_TASK_RUNNER.executeTaskList(taskList).then(() => {
+            console.log('[AsyncTaskRunnerService] ASYNC_TASK_RUNNER finished taskIds ==> ' + JSON.stringify(taskIds));
+        });
+    }
+    /**
+     * 是否存在新任务
+     * @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

@@ -1,7 +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>;
-}
+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>;
+}