midway-fatcms 0.0.1-beta.28 → 0.0.1-beta.29

package/dist/config/config.default.js

@@ -31,10 +31,10 @@ exports.default = (appInfo) => {
         },
         bodyParser: {
             enableTypes: ['json', 'form', 'text', 'xml'],
-            formLimit: '1mb',
-            jsonLimit: '1mb',
-            textLimit: '1mb',
-            xmlLimit: '1mb',
+            formLimit: '10mb',
+            jsonLimit: '10mb',
+            textLimit: '10mb',
+            xmlLimit: '10mb',
             ignore: [
                 '/ns/gw/proxy/*',
                 '/ns/gw/file/uploadFile',
@@ -179,6 +179,8 @@ exports.default = (appInfo) => {
             headerKey: 'fatcmsSAEnable',
             headerSecret: '222',
         },
+        // 用户会话保持时间，单位秒
+        fatcmsUserSessionKeepTimeSecond: 3600 * 24 * 30,
         // 是否启用内置的定时任务
         fatcmsScheduleService: true,
         // Excel导出文件的临时目录

package/dist/controller/manage/CrudStandardDesignApi.js

@@ -254,14 +254,14 @@ let CrudStandardDesignApi = class CrudStandardDesignApi extends BaseApiControlle
             throw new exceptions_1.CommonException('DB_NOT_FOUND', '数据库配置没有找到：' + dbName);
         }
         const schemaname = 'public';
-        const columnArraySql = `
-
-    SELECT
-      *
-      FROM information_schema.columns
-      WHERE table_schema = $1 and table_name = $2
-      ORDER BY ordinal_position;
-
+        const columnArraySql = `
+
+    SELECT
+      *
+      FROM information_schema.columns
+      WHERE table_schema = $1 and table_name = $2
+      ORDER BY ordinal_position;
+
     `.trim();
         const dbType = keys_1.SqlDbType.postgres;
         const columnArray = await this.curdMixService.executeSQL({

package/dist/middleware/global.middleware.js

@@ -37,6 +37,15 @@ function isBlob(obj) {
 function isStream(obj) {
     return obj && obj instanceof node_stream_1.Stream;
 }
+async function getUserSessionService(ctx) {
+    return ctx.requestContext.getAsync(UserSessionService_1.UserSessionService);
+}
+async function getWorkbenchService(ctx) {
+    return ctx.requestContext.getAsync(WorkbenchService_1.WorkbenchService);
+}
+async function getVisitStatService(ctx) {
+    return ctx.requestContext.getAsync(VisitStatService_1.VisitStatService);
+}
 /**
  * 专门对ExecuteSqlContext对象进行处理
  * @param res
@@ -121,15 +130,6 @@ function handleDebugRes(beforeRes, ctx, originRes) {
     nextRes.debugInfo = debugInfo;
     return nextRes;
 }
-async function getUserSessionService(ctx) {
-    return ctx.requestContext.getAsync(UserSessionService_1.UserSessionService);
-}
-async function getWorkbenchService(ctx) {
-    return ctx.requestContext.getAsync(WorkbenchService_1.WorkbenchService);
-}
-async function getVisitStatService(ctx) {
-    return ctx.requestContext.getAsync(VisitStatService_1.VisitStatService);
-}
 /**
  * 检查是否是超级管理员
  * @param ctx
@@ -155,6 +155,12 @@ function checkIsSuperAdmin(ctx, sessionInfo) {
     }
     return false;
 }
+/**
+ * 处理调试错误
+ * @param e
+ * @param ctx
+ * @returns
+ */
 function handleDebugError(e, ctx) {
     ctx.logger.error('GlobalMiddleware', e);
     let errorStack = null;
@@ -177,6 +183,10 @@ function handleDebugError(e, ctx) {
     }
     return res;
 }
+/**
+ * 数据埋点
+ * @param ctx
+ */
 async function trackRequest(ctx) {
     try {
         const visitStatService = await getVisitStatService(ctx);
@@ -186,6 +196,9 @@ async function trackRequest(ctx) {
         console.error('trackRequestError', e);
     }
 }
+/**
+ * 这些路径不需要配置用户信息等操作
+ */
 const excludePathPrefix = ['/ns/static/', '/ns/api/helpers'];
 /**
  * 全局中间件

package/dist/models/AsyncTaskModel.d.ts

@@ -70,3 +70,5 @@ export interface SysAsyncTaskHandlerConfig {
     priority?: number;
     expireSeconds?: number;
 }
+export declare const HEADER_KEY_RUN_BY_ASYNC_TASK_ID = "run-by-async-task-id";
+export declare const HEADER_KEY_RUN_BY_ASYNC_TASK_WORKBENCH_CODE = "run-by-async-task-workbenchcode";

package/dist/models/AsyncTaskModel.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SysAsyncFileFormat = exports.SysAsyncTaskStatus = void 0;
+exports.HEADER_KEY_RUN_BY_ASYNC_TASK_WORKBENCH_CODE = exports.HEADER_KEY_RUN_BY_ASYNC_TASK_ID = exports.SysAsyncFileFormat = exports.SysAsyncTaskStatus = void 0;
 var SysAsyncTaskStatus;
 (function (SysAsyncTaskStatus) {
     SysAsyncTaskStatus["PENDING"] = "PENDING";
@@ -27,3 +27,5 @@ var SysAsyncFileFormat;
     SysAsyncFileFormat["PNG"] = "png";
     SysAsyncFileFormat["JPG"] = "jpg";
 })(SysAsyncFileFormat = exports.SysAsyncFileFormat || (exports.SysAsyncFileFormat = {}));
+exports.HEADER_KEY_RUN_BY_ASYNC_TASK_ID = 'run-by-async-task-id';
+exports.HEADER_KEY_RUN_BY_ASYNC_TASK_WORKBENCH_CODE = 'run-by-async-task-workbenchcode';

package/dist/models/RedisKeys.d.ts

@@ -1,7 +1,9 @@
 declare const RedisKeys: {
     ASYNC_TASK_LOCK: string;
+    ASYNC_TASK_TIMEOUT_LOCK: string;
     ASYNC_TASK_UPDATE_TIME: string;
     USER_SESSION_PREFIX: string;
+    USER_SESSION_ASYNC_TASK_ID_PREFIX: string;
     USER_ACTION_TIME_LIMIT_PREFIX: string;
     VISIT_STAT_LOCK_PREFIX: string;
     VISIT_STAT_DATE_PREFIX: string;

package/dist/models/RedisKeys.js

@@ -3,8 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RedisKeys = void 0;
 const RedisKeys = {
     ASYNC_TASK_LOCK: 'FatAsyncTaskLock',
+    ASYNC_TASK_TIMEOUT_LOCK: 'FatAsyncTaskTimeoutLock',
     ASYNC_TASK_UPDATE_TIME: 'FatAsyncTaskUpdateTime',
     USER_SESSION_PREFIX: 'FatUserSession_',
+    USER_SESSION_ASYNC_TASK_ID_PREFIX: 'FatUserSessionAsyncTaskId_',
     USER_ACTION_TIME_LIMIT_PREFIX: 'FatUserActionTimeLimit_',
     VISIT_STAT_LOCK_PREFIX: 'FatVsLock_',
     VISIT_STAT_DATE_PREFIX: 'FatVsDate_',

package/dist/service/UserSessionService.d.ts

@@ -2,13 +2,34 @@ import { ISessionInfo } from '../models/userSession';
 export declare class UserSessionService {
     private ctx;
     private redisCacheService;
+    private curdProService;
+    private fatcmsUserSessionKeepTimeSecond;
+    /**
+     * 获取用户会话保持时间: 单位秒
+     * @returns
+     */
+    private getSessionKeepTimeSecond;
+    /**
+     * 保存用户会话信息
+     * @param sessionInfo
+     */
     saveUserSession(sessionInfo: ISessionInfo): Promise<void>;
     /**
      * 移除Session
      * @param sessionId
      */
     removeUserSession(sessionId: string): Promise<any>;
+    /**
+     * 获取用户会话信息
+     * @param sessionId
+     * @returns
+     */
     private getCurrentUserSessionForMiddleware1;
+    /**
+     * 从异步任务队列中获取当时用户的Session信息
+     * @param asyncTaskId
+     */
+    private getCurrentUserSessionByAsyncTaskId;
     /**
      * 专门给中间件点调用的
      */

package/dist/service/UserSessionService.js

@@ -15,6 +15,11 @@ 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");
+const AsyncTaskModel_1 = require("../models/AsyncTaskModel");
+const CurdProService_1 = require("./curd/CurdProService");
+const keys_1 = require("../libs/crud-pro/models/keys");
+const SystemTables_1 = require("../models/SystemTables");
+const global_config_1 = require("../libs/global-config/global-config");
 function pickUserAvatar(avatar) {
     if (!avatar) {
         return null;
@@ -45,10 +50,25 @@ const toCacheKey = (sessionId) => {
     return `${RedisKeys_1.RedisKeys.USER_SESSION_PREFIX}${sessionId}`;
 };
 let UserSessionService = class UserSessionService {
+    /**
+     * 获取用户会话保持时间: 单位秒
+     * @returns
+     */
+    getSessionKeepTimeSecond() {
+        if (typeof this.fatcmsUserSessionKeepTimeSecond === 'number' && this.fatcmsUserSessionKeepTimeSecond > 0) {
+            return this.fatcmsUserSessionKeepTimeSecond;
+        }
+        return SESSION_KEEP_TIME_SECOND;
+    }
+    /**
+     * 保存用户会话信息
+     * @param sessionInfo
+     */
     async saveUserSession(sessionInfo) {
         sessionInfo.avatar = pickUserAvatar(sessionInfo.avatar);
         const sessionId = sessionInfo.sessionId;
-        await this.redisCacheService.setJsonObject(toCacheKey(sessionId), sessionInfo, SESSION_KEEP_TIME_SECOND);
+        const keepTime = this.getSessionKeepTimeSecond();
+        await this.redisCacheService.setJsonObject(toCacheKey(sessionId), sessionInfo, keepTime);
     }
     /**
      * 移除Session
@@ -57,16 +77,58 @@ let UserSessionService = class UserSessionService {
     async removeUserSession(sessionId) {
         return await this.redisCacheService.removeItem(toCacheKey(sessionId));
     }
+    /**
+     * 获取用户会话信息
+     * @param sessionId
+     * @returns
+     */
     async getCurrentUserSessionForMiddleware1(sessionId) {
         if (!sessionId) {
             return null;
         }
         return await this.redisCacheService.getJsonObject(toCacheKey(sessionId));
     }
+    /**
+     * 从异步任务队列中获取当时用户的Session信息
+     * @param asyncTaskId
+     */
+    async getCurrentUserSessionByAsyncTaskId(asyncTaskId) {
+        const taskSessionCacheKey = `${RedisKeys_1.RedisKeys.USER_SESSION_ASYNC_TASK_ID_PREFIX}${asyncTaskId}`;
+        const loadSessionInfo = async () => {
+            const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
+            const asyncTaskRes = await this.curdProService.executeCrudByCfg({
+                columns: ['id', 'created_user_session'],
+                condition: {
+                    id: asyncTaskId,
+                }
+            }, {
+                sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY_ONE,
+                sqlTable: SystemTables_1.SystemTables.sys_async_tasks,
+                sqlDatabase: SystemDbName,
+                sqlDbType: SystemDbType,
+            });
+            const asyncTaskObj = asyncTaskRes.getOneObj();
+            if (!asyncTaskObj) {
+                return null;
+            }
+            return (0, functions_1.parseJsonObject)(asyncTaskObj.created_user_session);
+        };
+        let sessionInfo1 = await this.redisCacheService.getJsonObject(taskSessionCacheKey);
+        if (!sessionInfo1) {
+            sessionInfo1 = await loadSessionInfo();
+            await this.redisCacheService.setJsonObject(taskSessionCacheKey, sessionInfo1, 3600); // 只缓存一小时即可
+        }
+        return sessionInfo1;
+    }
     /**
      * 专门给中间件点调用的
      */
     async getCurrentUserSessionForMiddleware() {
+        // 先从Header中获取：异步任务队列的任务ID
+        const asyncTaskId = this.ctx.headers[AsyncTaskModel_1.HEADER_KEY_RUN_BY_ASYNC_TASK_ID];
+        if (asyncTaskId && typeof asyncTaskId === 'string') {
+            return this.getCurrentUserSessionByAsyncTaskId(asyncTaskId);
+        }
         const cookies = this.ctx.cookies;
         const sessionId = cookies.get(userSession_1.SESSION_ID_KEY, userSession_1.sessionCookieCfg);
         return this.getCurrentUserSessionForMiddleware1(sessionId);
@@ -80,6 +142,14 @@ __decorate([
     (0, core_1.Inject)(),
     __metadata("design:type", RedisCacheService_1.RedisCacheService)
 ], UserSessionService.prototype, "redisCacheService", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", CurdProService_1.CurdProService)
+], UserSessionService.prototype, "curdProService", void 0);
+__decorate([
+    (0, core_1.Config)('fatcmsUserSessionKeepTimeSecond'),
+    __metadata("design:type", Number)
+], UserSessionService.prototype, "fatcmsUserSessionKeepTimeSecond", void 0);
 UserSessionService = __decorate([
     (0, core_1.Provide)()
 ], UserSessionService);

package/dist/service/WorkbenchService.d.ts

@@ -7,13 +7,45 @@ export declare class WorkbenchService extends BaseService implements IScheduleSe
     private curdProService;
     clearCache(): void;
     runBySchedule(): Promise<void>;
+    /**
+     * 获取所有站点列表
+     * @param isForceRefresh 是否强制刷新缓存
+     * @returns
+     */
     getAllWorkbenchInfoList(isForceRefresh?: boolean): Promise<IWorkbenchEntity[]>;
+    /**
+     * 获取所有站点列表，以map的形式返回。其中key为站点域名，value为站点信息
+     * @param isForceRefresh 是否强制刷新缓存
+     * @returns
+     */
     getAllWorkbenchInfoMap(isForceRefresh?: boolean): Promise<Record<any, IWorkbenchEntity>>;
+    /**
+     * 检查站点编码是否匹配
+     * @param workbench_code_array 站点编码数组
+     * @param workbench_code 站点编码
+     * @returns
+     */
     isMatchWorkbenchCode(workbench_code_array: string | string[], workbench_code: string): boolean;
+    /**
+     * 根据站点编码获取站点信息
+     * @param workbenchCode 站点编码
+     * @returns
+     */
+    private getWorkbenchInfoByCode;
+    /**
+     * 根据域名获取站点信息
+     * @param host 域名
+     * @returns
+     */
+    private getWorkbenchInfoByHost;
     /**
      * 获取当前请求的域名所对应的站点信息
      */
     getCurrentHostWorkbenchInfo(): Promise<IWorkbenchEntity>;
+    /**
+     * 获取当前请求的域名
+     * @returns
+     */
     private getCurrentHost;
     isSupportCurrentWorkbench(workbench_code_array: string | string[]): Promise<boolean>;
     isSupportCurrentHostForForMiddleware(): Promise<string | boolean>;

package/dist/service/WorkbenchService.js

@@ -21,6 +21,7 @@ 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 AsyncTaskModel_1 = require("../models/AsyncTaskModel");
 //
 // const lruCache = new LRUCache<string, any>({
 //   max: 500,
@@ -38,6 +39,11 @@ let WorkbenchService = class WorkbenchService extends BaseService_1.BaseService
     async runBySchedule() {
         await this.getAllWorkbenchInfoMap(true);
     }
+    /**
+     * 获取所有站点列表
+     * @param isForceRefresh 是否强制刷新缓存
+     * @returns
+     */
     async getAllWorkbenchInfoList(isForceRefresh) {
         const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
         let listData = lruCache.get(CACHE_KEY_WORKBENCH_LIST);
@@ -54,6 +60,11 @@ let WorkbenchService = class WorkbenchService extends BaseService_1.BaseService
         }
         return listData;
     }
+    /**
+     * 获取所有站点列表，以map的形式返回。其中key为站点域名，value为站点信息
+     * @param isForceRefresh 是否强制刷新缓存
+     * @returns
+     */
     async getAllWorkbenchInfoMap(isForceRefresh) {
         let listData;
         let domainMap = lruCache.get(CACHE_KEY_DOMAIN_MAP);
@@ -67,6 +78,12 @@ let WorkbenchService = class WorkbenchService extends BaseService_1.BaseService
         }
         return domainMap;
     }
+    /**
+     * 检查站点编码是否匹配
+     * @param workbench_code_array 站点编码数组
+     * @param workbench_code 站点编码
+     * @returns
+     */
     isMatchWorkbenchCode(workbench_code_array, workbench_code) {
         if (workbench_code_array === '*') {
             return true;
@@ -76,6 +93,30 @@ let WorkbenchService = class WorkbenchService extends BaseService_1.BaseService
             .filter(Boolean);
         return supportWorkbenchArray.includes('*') || supportWorkbenchArray.includes(workbench_code);
     }
+    /**
+     * 根据站点编码获取站点信息
+     * @param workbenchCode 站点编码
+     * @returns
+     */
+    async getWorkbenchInfoByCode(workbenchCode) {
+        const list = await this.getAllWorkbenchInfoList();
+        for (let i = 0; i < list.length; i++) {
+            const workbenchInfo = list[i];
+            if (workbenchInfo.workbench_code === workbenchCode) {
+                return workbenchInfo;
+            }
+        }
+        return null;
+    }
+    /**
+     * 根据域名获取站点信息
+     * @param host 域名
+     * @returns
+     */
+    async getWorkbenchInfoByHost(host) {
+        const domainMap = await this.getAllWorkbenchInfoMap();
+        return domainMap[host];
+    }
     /**
      * 获取当前请求的域名所对应的站点信息
      */
@@ -86,24 +127,26 @@ let WorkbenchService = class WorkbenchService extends BaseService_1.BaseService
             if (!debugWorkbenchCode) {
                 throw new exceptions_1.CommonException('本地环境调试时需要使用ModHeader浏览器插件，指定站点编码');
             }
-            const list = await this.getAllWorkbenchInfoList();
-            for (let i = 0; i < list.length; i++) {
-                const workbenchInfo = list[i];
-                if (workbenchInfo.workbench_code === debugWorkbenchCode) {
-                    return workbenchInfo;
-                }
-            }
-            return null;
+            return await this.getWorkbenchInfoByCode(debugWorkbenchCode);
+        }
+        // 内部异步任务，指定了workbench code
+        const asyncTaskWorkbenchCode = this.ctx.headers[AsyncTaskModel_1.HEADER_KEY_RUN_BY_ASYNC_TASK_WORKBENCH_CODE];
+        if (asyncTaskWorkbenchCode && typeof asyncTaskWorkbenchCode === 'string') {
+            return await this.getWorkbenchInfoByCode(asyncTaskWorkbenchCode);
         }
         //正式环境： 根据域名获取站点配置
         const host = this.getCurrentHost();
-        const domainMap = await this.getAllWorkbenchInfoMap();
-        const workbenchInfo = domainMap[host];
+        const workbenchInfo = await this.getWorkbenchInfoByHost(host);
         if (workbenchInfo) {
             return workbenchInfo;
         }
-        return domainMap['*']; // 最后兜底
+        // 最后兜底
+        return await this.getWorkbenchInfoByHost("*");
     }
+    /**
+     * 获取当前请求的域名
+     * @returns
+     */
     getCurrentHost() {
         const host = this.ctx.request.host;
         if (!host) {

package/dist/service/anyapi/AnyApiSandboxService.js

@@ -74,18 +74,18 @@ let AnyApiSandboxService = class AnyApiSandboxService extends BaseService_1.Base
             };
             const nextLine100 = new Array(10).fill('\n').join('');
             const bindCode = this.toBindCodeString('httpController', newContext, 'sandbox');
-            const code = `
-      (async () => {
-        ${nextLine100}${func_code}; // 必须有一个 class HttpController { async handleRequest(params){} }
-        ${nextLine100}
-        try {
-          const httpController = new HttpController();
-          ${bindCode}
-          const res = await httpController.handleRequest(sandbox.allParams.params);
-          sandbox.returnSuccess(res);
-        } catch (e) {
-          sandbox.returnError(e)
-        }
+            const code = `
+      (async () => {
+        ${nextLine100}${func_code}; // 必须有一个 class HttpController { async handleRequest(params){} }
+        ${nextLine100}
+        try {
+          const httpController = new HttpController();
+          ${bindCode}
+          const res = await httpController.handleRequest(sandbox.allParams.params);
+          sandbox.returnSuccess(res);
+        } catch (e) {
+          sandbox.returnError(e)
+        }
       })(); `;
             try {
                 const script = getCompiledScript(anyApi, code);

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

@@ -26,8 +26,21 @@ 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>;
+    /**
+     * 更新超时的任务状态
+     * @returns
+     */
+    private runByScheduleForTimeoutTasks;
+    /**
+     * 检查是否有新任务。如果有，就从数据库中获取一批任务，放到自己的任务队列里。
+     * @returns
+     */
+    private runByScheduleForPendingTasks;
+    fetchPendingTasks(): Promise<void>;
     /**
      * 是否存在新任务
      * @private

package/dist/service/asyncTask/AsyncTaskRunnerService.js

@@ -10,6 +10,7 @@ var __metadata = (this && this.__metadata) || function (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");
@@ -93,6 +94,8 @@ class AsyncTaskRunner {
         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,
@@ -125,6 +128,7 @@ exports.ASYNC_TASK_RUNNER.taskHandlerMap.set('EXCEL_EXPORT', new ExportExcelAsyn
  * Redis锁
  */
 const ASYNC_TASK_LOCK = RedisKeys_1.RedisKeys.ASYNC_TASK_LOCK;
+const ASYNC_TASK_TIMEOUT_LOCK = RedisKeys_1.RedisKeys.ASYNC_TASK_TIMEOUT_LOCK;
 /**
  * 上次检查异步任务的时间点
  */
@@ -132,6 +136,72 @@ 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");
+        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();
         // 只获取本进程能够处理的任务类型。
@@ -181,31 +251,6 @@ let AsyncTaskRunnerService = class AsyncTaskRunnerService extends BaseService_1.
             console.log('[AsyncTaskRunnerService] 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('[AsyncTaskRunnerService] fetchPendingTasks error', (0, errorToString_1.errorToString)(e));
-        }
-        await this.redisService.del(ASYNC_TASK_LOCK);
-        return Promise.resolve();
-    }
     /**
      * 是否存在新任务
      * @private

package/dist/service/asyncTask/handler/ExportExcelByInnerHttpHandler.js

@@ -3,7 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExportExcelByInnerHttpHandler = void 0;
 const _ = require("lodash");
 const axios_1 = require("axios");
+const AsyncTaskModel_1 = require("../../../models/AsyncTaskModel");
 const schedule_1 = require("../../../schedule");
+const functions_1 = require("../../../libs/utils/functions");
 function pickData(a, key) {
     if (a && typeof a.getResModel === 'function') {
         const s = a.getResModel();
@@ -63,12 +65,19 @@ class ExportExcelByInnerHttpHandler {
         if (!queryApi.startsWith('/')) {
             queryApi = '/' + queryApi;
         }
-        params.runByExportExcel = true;
+        const asyncTaskId = this.asyncTaskContext.task.id;
+        const createdUserSession = (0, functions_1.parseJsonObject)(this.asyncTaskContext.task.created_user_session);
+        const workbenchCode = createdUserSession.workbenchCode;
+        params[AsyncTaskModel_1.HEADER_KEY_RUN_BY_ASYNC_TASK_ID] = asyncTaskId;
+        params[AsyncTaskModel_1.HEADER_KEY_RUN_BY_ASYNC_TASK_WORKBENCH_CODE] = workbenchCode;
+        const headers = this.inputParams.headers || {};
+        headers[AsyncTaskModel_1.HEADER_KEY_RUN_BY_ASYNC_TASK_ID] = asyncTaskId;
+        headers[AsyncTaskModel_1.HEADER_KEY_RUN_BY_ASYNC_TASK_WORKBENCH_CODE] = workbenchCode;
         const response = await (0, axios_1.default)({
             method: 'POST',
             url: `http://127.0.0.1:${port}${queryApi}`,
             data: params,
-            headers: this.inputParams.headers || {},
+            headers: headers,
             responseType: 'json',
             validateStatus: () => true,
         });

package/dist/service/base/RedisCacheService.d.ts

@@ -8,6 +8,13 @@ export declare class RedisCacheService {
     protected redisService: RedisService;
     protected ossServiceFactory: OSSServiceFactory;
     getJsonObject(key: string): Promise<any>;
+    /**
+     * 设置缓存对象
+     * @param key
+     * @param obj
+     * @param expireSecond 过期时间，单位秒
+     * @returns
+     */
     setJsonObject(key: string, obj: any, expireSecond: number): Promise<any>;
     removeItem(key: string): Promise<any>;
 }

package/dist/service/base/RedisCacheService.js

@@ -20,6 +20,13 @@ let RedisCacheService = class RedisCacheService {
         const str = await this.redisService.get(key);
         return (0, functions_1.parseJsonObject)(str);
     }
+    /**
+     * 设置缓存对象
+     * @param key
+     * @param obj
+     * @param expireSecond 过期时间，单位秒
+     * @returns
+     */
     async setJsonObject(key, obj, expireSecond) {
         const str = JSON.stringify(obj);
         return this.redisService.set(key, str, 'EX', expireSecond);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "midway-fatcms",
-  "version": "0.0.1-beta.28",
+  "version": "0.0.1-beta.29",
   "description": "This is a midway component sample",
   "main": "dist/index.js",
   "typings": "index.d.ts",