midway-fatcms 0.0.1-beta.26 → 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/home.controller.js

@@ -39,7 +39,8 @@ let HomeController = class HomeController extends BaseApiController_1.BaseApiCon
             package_assets: workbenchInfo.package_assets,
             fatcmscsrftoken,
         });
-        return this.ctx.renderString(html_content, { workbenchInfo, userInfo, utils }, { viewEngine: 'ejs' });
+        const query = this.ctx.query || {};
+        return this.ctx.renderString(html_content, { workbenchInfo, userInfo, utils, query }, { viewEngine: 'ejs' });
     }
     async robots() {
         return `User-agent: * \nDisallow: /ns/api/manage/`;

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/controller/render/AppRenderController.js

@@ -61,7 +61,8 @@ let AppRenderController = class AppRenderController extends BaseApiController_1.
             package_assets: appInfo.package_assets,
             fatcmscsrftoken,
         });
-        return this.ctx.renderString(html_content, { appInfo, workbenchInfo, userInfo, utils }, { viewEngine: 'ejs' });
+        const query = this.ctx.query || {};
+        return this.ctx.renderString(html_content, { appInfo, workbenchInfo, userInfo, utils, query }, { viewEngine: 'ejs' });
     }
     async isSupportCurrentWorkbench(appInfo) {
         if (this.isLocalEnv()) {

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/models/bizmodels.d.ts

@@ -24,6 +24,7 @@ export interface IStdCrudCfgObj {
     toolbarList?: any[];
 }
 export interface ICrudStdAppInfo {
+    app_code: string;
     stdCrudCfgObj?: IStdCrudCfgObj;
     actionsMap?: any;
     status: number;

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