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

package/dist/service/base/cache/FatcmsBaseRedisCache.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FatcmsBaseRedisCache = void 0;
+const functions_1 = require("../../../libs/utils/functions");
+class FatcmsBaseRedisCache {
+    constructor(ctx, cacheName, redisService) {
+        this.ctx = ctx;
+        this.cacheName = cacheName;
+        this.redisService = redisService;
+    }
+    getCacheKey(key) {
+        return `${this.cacheName}${key}`;
+    }
+    async getJsonObject(key) {
+        const cacheKey = this.getCacheKey(key);
+        const str = await this.redisService.get(cacheKey);
+        return (0, functions_1.parseJsonObject)(str);
+    }
+    /**
+     * 设置缓存对象
+     * @param key
+     * @param obj
+     * @param expireSecond 过期时间，单位秒
+     * @returns
+     */
+    async setJsonObject(key, obj, expireSecond) {
+        const cacheKey = this.getCacheKey(key);
+        if (!expireSecond) {
+            expireSecond = 60;
+        }
+        const str = JSON.stringify(obj);
+        return this.redisService.set(cacheKey, str, 'EX', expireSecond);
+    }
+    async removeItem(key) {
+        const cacheKey = this.getCacheKey(key);
+        return await this.redisService.del(cacheKey);
+    }
+}
+exports.FatcmsBaseRedisCache = FatcmsBaseRedisCache;

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

@@ -7,6 +7,7 @@ import { ExecuteContext } from '../../libs/crud-pro/models/ExecuteContext';
 import { CrudStdActionService } from './CrudStdActionService';
 import { CrudStdRelationService } from './CrudStdRelationService';
 import { ApiBaseService } from '../base/ApiBaseService';
+import { CacheServiceFactory } from '../base/cache/CacheServiceFactory';
 export declare const SPECIAL_SETTING_KEY: {
     QUERY_LIST: string;
     QUERY_ONE: string;
@@ -25,6 +26,7 @@ export declare class CrudStdService extends ApiBaseService {
     protected curdMixService: CurdMixService;
     protected crudStdActionService: CrudStdActionService;
     protected crudStdRelationService: CrudStdRelationService;
+    protected cacheServiceFactory: CacheServiceFactory;
     /**
      * 执行普通CRUD
      */
@@ -51,10 +53,10 @@ export declare class CrudStdService extends ApiBaseService {
      */
     private getCrudStdAppInfo;
     /**
-   * 查询APP信息
-   * @param appCode
-   * @private
-   */
+     * 查询APP信息
+     * @param appCode
+     * @private
+     */
     getParsedCrudStdAppInfo(appCode: string): Promise<ICrudStdAppInfo>;
     /**
      * 查询APP信息

package/dist/service/crudstd/CrudStdService.js

@@ -25,11 +25,15 @@ const ApiBaseService_1 = require("../base/ApiBaseService");
 const DatabaseName_1 = require("../../libs/crud-pro/utils/DatabaseName");
 const global_config_1 = require("../../libs/global-config/global-config");
 const MixinUtils_1 = require("../../libs/crud-pro/utils/MixinUtils");
+const CacheServiceFactory_1 = require("../base/cache/CacheServiceFactory");
+const SystemEntities_1 = require("../../models/SystemEntities");
 exports.SPECIAL_SETTING_KEY = {
     QUERY_LIST: 'QUERY_LIST',
     QUERY_ONE: 'QUERY_ONE',
     KANBAN_VIEW_STATUS_UPDATE: 'KANBAN_VIEW_STATUS_UPDATE', // 看板视图中更新状态
 };
+const DEFAULT_CACHE_LEVEL = SystemEntities_1.CacheLevelEnum.MEMORY;
+const DEFAULT_CACHE_SECOND = 60 * 5;
 function isNotEmptyStr(str) {
     return typeof str === 'string' && str.trim().length > 0;
 }
@@ -228,17 +232,23 @@ let CrudStdService = class CrudStdService extends ApiBaseService_1.ApiBaseServic
         return await this.curdMixService.executeCrudByCfg({ condition: { app_code: appCode } }, ss);
     }
     /**
-   * 查询APP信息
-   * @param appCode
-   * @private
-   */
+     * 查询APP信息
+     * @param appCode
+     * @private
+     */
     async getParsedCrudStdAppInfo(appCode) {
-        const cacheKey = 'getParsedCrudStdAppInfo:' + appCode;
-        let appInfo = this.getFromCtxCache(cacheKey);
-        if (!appInfo) {
-            appInfo = await this.getParsedCrudStdAppInfoPrivate(appCode);
-            this.setToCtxCache(cacheKey, appInfo);
-        }
+        const { crudStdAppInfoCacheLevel, crudStdAppInfoCacheSecond } = this.ctx.workbenchInfoTools.getWorkbenchConfig();
+        const cacheSecond = crudStdAppInfoCacheSecond || DEFAULT_CACHE_SECOND;
+        const cacheLevel = crudStdAppInfoCacheLevel || DEFAULT_CACHE_LEVEL;
+        let appInfo = await this.cacheServiceFactory.getJsonObjectCache({
+            cacheLevel,
+            cacheKey: appCode,
+            cacheSecond,
+            cacheName: SystemEntities_1.CacheNameEnum.GetParsedCrudStdAppInfo,
+            getter: async () => {
+                return await this.getParsedCrudStdAppInfoPrivate(appCode);
+            },
+        });
         return appInfo;
     }
     /**
@@ -397,6 +407,10 @@ __decorate([
     (0, core_1.Inject)(),
     __metadata("design:type", CrudStdRelationService_1.CrudStdRelationService)
 ], CrudStdService.prototype, "crudStdRelationService", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", CacheServiceFactory_1.CacheServiceFactory)
+], CrudStdService.prototype, "cacheServiceFactory", void 0);
 CrudStdService = __decorate([
     (0, core_1.Provide)()
 ], CrudStdService);

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

@@ -1,10 +1,9 @@
 import { Context } from '@midwayjs/koa';
 import { HandleExecuteContextType, IExecuteContextHandler } from '../../libs/crud-pro/models/ExecuteContext';
-import { RedisCacheService } from '../base/RedisCacheService';
 export declare class CurdMixByDictService implements IExecuteContextHandler {
     ctx: Context;
     private curdProService;
-    protected redisCacheService: RedisCacheService;
+    private cacheServiceFactory;
     private getFromCache;
     private setToCache;
     handleExecuteContextPrepare(executeContext: HandleExecuteContextType): Promise<void>;

package/dist/service/curd/CurdMixByDictService.js

@@ -17,19 +17,23 @@ const CurdMixUtils_1 = require("./CurdMixUtils");
 const SystemTables_1 = require("../../models/SystemTables");
 const keys_1 = require("../../libs/crud-pro/models/keys");
 const MultiKeyMap_1 = require("../../libs/crud-pro/utils/MultiKeyMap");
-const RedisCacheService_1 = require("../base/RedisCacheService");
 const global_config_1 = require("../../libs/global-config/global-config");
-const RedisKeys_1 = require("../../models/RedisKeys");
+const CacheServiceFactory_1 = require("../base/cache/CacheServiceFactory");
+const SystemEntities_1 = require("../../models/SystemEntities");
 const TMP_CTX_KEY = _.uniqueId('CurdMixByDictService');
 const dictMixUtils = new CurdMixUtils_1.CrudMixUtils(CurdMixUtils_1.RelatedType.dict);
+const DEFAULT_CACHE_LEVEL = SystemEntities_1.CacheLevelEnum.MEMORY;
+const DEFAULT_CACHE_SECOND = 60 * 5;
 let CurdMixByDictService = class CurdMixByDictService {
     async getFromCache(code) {
-        const cacheKey = `${RedisKeys_1.RedisKeys.CURD_MIX_BY_DICT_PREFIX}${code}`;
-        return this.redisCacheService.getJsonObject(cacheKey);
+        const { curdMixByCommonCacheLevel } = this.ctx.workbenchInfoTools.getWorkbenchConfig();
+        const cacheService = this.cacheServiceFactory.getCacheService(curdMixByCommonCacheLevel || DEFAULT_CACHE_LEVEL, SystemEntities_1.CacheNameEnum.CurdMixByDict);
+        return cacheService.getJsonObject(code);
     }
     async setToCache(code, value) {
-        const cacheKey = `${RedisKeys_1.RedisKeys.CURD_MIX_BY_DICT_PREFIX}${code}`;
-        return this.redisCacheService.setJsonObject(cacheKey, value, 60 * 60);
+        const { curdMixByCommonCacheLevel, curdMixByCommonCacheSecond } = this.ctx.workbenchInfoTools.getWorkbenchConfig();
+        const cacheService = this.cacheServiceFactory.getCacheService(curdMixByCommonCacheLevel || DEFAULT_CACHE_LEVEL, SystemEntities_1.CacheNameEnum.CurdMixByDict);
+        return cacheService.setJsonObject(code, value, curdMixByCommonCacheSecond || DEFAULT_CACHE_SECOND);
     }
     async handleExecuteContextPrepare(executeContext) {
         const codes = dictMixUtils.pickColumnRelationCodes(executeContext);
@@ -106,8 +110,8 @@ __decorate([
 ], CurdMixByDictService.prototype, "curdProService", void 0);
 __decorate([
     (0, core_1.Inject)(),
-    __metadata("design:type", RedisCacheService_1.RedisCacheService)
-], CurdMixByDictService.prototype, "redisCacheService", void 0);
+    __metadata("design:type", CacheServiceFactory_1.CacheServiceFactory)
+], CurdMixByDictService.prototype, "cacheServiceFactory", void 0);
 CurdMixByDictService = __decorate([
     (0, core_1.Provide)()
 ], CurdMixByDictService);

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

@@ -1,11 +1,10 @@
 import { Context } from '@midwayjs/koa';
 import { CurdProService } from './CurdProService';
 import { HandleExecuteContextType, IExecuteContextHandler } from '../../libs/crud-pro/models/ExecuteContext';
-import { RedisCacheService } from '../base/RedisCacheService';
 export declare class CurdMixByLinkToCustomService implements IExecuteContextHandler {
     protected ctx: Context;
     protected curdProService: CurdProService;
-    protected redisCacheService: RedisCacheService;
+    private cacheServiceFactory;
     handleExecuteContextPrepare(executeContext: HandleExecuteContextType): Promise<void>;
     handleExecuteContext(executeContext: HandleExecuteContextType): Promise<void>;
     queryInfoByLinkToCustom(code: string): Promise<Map<string, any>>;

package/dist/service/curd/CurdMixByLinkToCustomService.js

@@ -17,12 +17,15 @@ const CurdMixUtils_1 = require("./CurdMixUtils");
 const keys_1 = require("../../libs/crud-pro/models/keys");
 const devops_1 = require("../../models/devops");
 const exceptions_1 = require("../../libs/crud-pro/exceptions");
-const RedisCacheService_1 = require("../base/RedisCacheService");
 const DatabaseName_1 = require("../../libs/crud-pro/utils/DatabaseName");
 const global_config_1 = require("../../libs/global-config/global-config");
-const RedisKeys_1 = require("../../models/RedisKeys");
+const SystemEntities_1 = require("../../models/SystemEntities");
+const CacheServiceFactory_1 = require("../base/cache/CacheServiceFactory");
+const md5 = require("md5");
 const linkToCustomMixUtils = new CurdMixUtils_1.CrudMixUtils(CurdMixUtils_1.RelatedType.linkToCustom);
 const TMP_CTX_KEY = _.uniqueId('CurdMixByLinkToCustomService');
+const DEFAULT_CACHE_LEVEL = SystemEntities_1.CacheLevelEnum.MEMORY;
+const DEFAULT_CACHE_SECOND = 60 * 5;
 function toMapObject(rows, fieldsArr) {
     const valueKey = fieldsArr[0];
     const labelKey = fieldsArr[1];
@@ -79,15 +82,16 @@ let CurdMixByLinkToCustomService = class CurdMixByLinkToCustomService {
         });
     }
     async queryInfoByLinkToCustom(code) {
-        const cacheKey = RedisKeys_1.RedisKeys.LINK_TO_CUSTOM_PREFIX + code;
-        let values;
-        const expireSecond = 2 * 60; // 2分钟
-        const enumMap = await this.redisCacheService.getJsonObject(cacheKey);
-        if (!enumMap || Object.keys(enumMap).length === 0) {
-            values = await this.queryInfoByLinkToCustomImpl(code);
-            await this.redisCacheService.setJsonObject(cacheKey, values, expireSecond);
-        }
-        return values;
+        const { curdMixByCommonCacheLevel, curdMixByCommonCacheSecond } = this.ctx.workbenchInfoTools.getWorkbenchConfig();
+        return this.cacheServiceFactory.getJsonObjectCache({
+            cacheLevel: curdMixByCommonCacheLevel || DEFAULT_CACHE_LEVEL,
+            cacheKey: md5(code),
+            cacheSecond: curdMixByCommonCacheSecond || DEFAULT_CACHE_SECOND,
+            cacheName: SystemEntities_1.CacheNameEnum.CurdMixByLinkToCustom,
+            getter: async () => {
+                return await this.queryInfoByLinkToCustomImpl(code);
+            },
+        });
     }
     /**
      * code形如：mysql_________fatcms~~~sys_perm_role~~~role_code,role_name,xxx_name
@@ -195,8 +199,8 @@ __decorate([
 ], CurdMixByLinkToCustomService.prototype, "curdProService", void 0);
 __decorate([
     (0, core_1.Inject)(),
-    __metadata("design:type", RedisCacheService_1.RedisCacheService)
-], CurdMixByLinkToCustomService.prototype, "redisCacheService", void 0);
+    __metadata("design:type", CacheServiceFactory_1.CacheServiceFactory)
+], CurdMixByLinkToCustomService.prototype, "cacheServiceFactory", void 0);
 CurdMixByLinkToCustomService = __decorate([
     (0, core_1.Provide)()
 ], CurdMixByLinkToCustomService);

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

@@ -4,6 +4,10 @@ import { HandleExecuteContextType, IExecuteContextHandler } from '../../libs/cru
 export declare class CurdMixBySysConfigService implements IExecuteContextHandler {
     ctx: Context;
     protected curdProService: CurdProService;
+    private cacheServiceFactory;
+    private getFromCache;
+    private setToCache;
+    private queryConfigRowsUseCache;
     handleExecuteContextPrepare(executeContext: HandleExecuteContextType): Promise<void>;
     handleExecuteContext(executeContext: HandleExecuteContextType): Promise<void>;
 }

package/dist/service/curd/CurdMixBySysConfigService.js

@@ -19,17 +19,39 @@ const keys_1 = require("../../libs/crud-pro/models/keys");
 const MultiKeyMap_1 = require("../../libs/crud-pro/utils/MultiKeyMap");
 const parseConfig_1 = require("../../libs/utils/parseConfig");
 const global_config_1 = require("../../libs/global-config/global-config");
+const CacheServiceFactory_1 = require("../base/cache/CacheServiceFactory");
+const SystemEntities_1 = require("../../models/SystemEntities");
 const dictMixUtils = new CurdMixUtils_1.CrudMixUtils(CurdMixUtils_1.RelatedType.sysCfgEnum);
 const TMP_CTX_KEY = _.uniqueId('CurdMixBySysConfigService');
+const DEFAULT_CACHE_LEVEL = SystemEntities_1.CacheLevelEnum.MEMORY;
+const DEFAULT_CACHE_SECOND = 60 * 5;
 let CurdMixBySysConfigService = class CurdMixBySysConfigService {
-    async handleExecuteContextPrepare(executeContext) {
-        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
-        const codes = dictMixUtils.pickColumnRelationCodes(executeContext);
-        if (!codes || codes.length === 0) {
-            return;
+    async getFromCache(code) {
+        const { curdMixByCommonCacheLevel } = this.ctx.workbenchInfoTools.getWorkbenchConfig();
+        const cacheService = this.cacheServiceFactory.getCacheService(curdMixByCommonCacheLevel || DEFAULT_CACHE_LEVEL, SystemEntities_1.CacheNameEnum.CurdMixBySysConfig);
+        return cacheService.getJsonObject(code);
+    }
+    async setToCache(code, value) {
+        const { curdMixByCommonCacheLevel, curdMixByCommonCacheSecond } = this.ctx.workbenchInfoTools.getWorkbenchConfig();
+        const cacheService = this.cacheServiceFactory.getCacheService(curdMixByCommonCacheLevel || DEFAULT_CACHE_LEVEL, SystemEntities_1.CacheNameEnum.CurdMixBySysConfig);
+        return cacheService.setJsonObject(code, value, curdMixByCommonCacheSecond || DEFAULT_CACHE_SECOND);
+    }
+    async queryConfigRowsUseCache(codes) {
+        const resultRowMap = {};
+        for (let i = 0; i < codes.length; i++) {
+            const code = codes[i];
+            const row = await this.getFromCache(code);
+            if (row) {
+                resultRowMap[code] = row;
+            }
+        }
+        const notCachedCodes = codes.filter((code) => !resultRowMap[code]);
+        if (notCachedCodes.length === 0) {
+            return Object.values(resultRowMap);
         }
+        const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
         const res1 = await this.curdProService.executeCrudByCfg({
-            condition: { config_code: { $in: codes } },
+            condition: { config_code: { $in: notCachedCodes } },
         }, {
             sqlTable: SystemTables_1.SystemTables.sys_configs,
             sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY,
@@ -37,15 +59,29 @@ let CurdMixBySysConfigService = class CurdMixBySysConfigService {
             sqlDbType: SystemDbType,
         });
         const rows = res1.getResRows();
-        const multiKeyMap = new MultiKeyMap_1.MultiKeyMap();
-        if (Array.isArray(rows)) {
+        if (Array.isArray(rows) && rows.length > 0) {
             for (let i = 0; i < rows.length; i++) {
                 const row = rows[i];
                 const { config_code } = row;
-                const config_content_rows = (0, parseConfig_1.parseConfigContentToEnumInfo)(row); // 数组元素必须有value字段
-                multiKeyMap.addRowsValue1(config_content_rows, config_code, 'value');
+                await this.setToCache(config_code, row);
+                resultRowMap[config_code] = row;
             }
         }
+        return Object.values(resultRowMap);
+    }
+    async handleExecuteContextPrepare(executeContext) {
+        const codes = dictMixUtils.pickColumnRelationCodes(executeContext);
+        if (!codes || codes.length === 0) {
+            return;
+        }
+        const multiKeyMap = new MultiKeyMap_1.MultiKeyMap();
+        const rows = await this.queryConfigRowsUseCache(codes);
+        for (let i = 0; i < rows.length; i++) {
+            const row = rows[i];
+            const { config_code } = row;
+            const config_content_rows = (0, parseConfig_1.parseConfigContentToEnumInfo)(row); // 数组元素必须有value字段
+            multiKeyMap.addRowsValue1(config_content_rows, config_code, 'value');
+        }
         executeContext[TMP_CTX_KEY] = multiKeyMap;
     }
     async handleExecuteContext(executeContext) {
@@ -74,6 +110,10 @@ __decorate([
     (0, core_1.Inject)(),
     __metadata("design:type", CurdProService_1.CurdProService)
 ], CurdMixBySysConfigService.prototype, "curdProService", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", CacheServiceFactory_1.CacheServiceFactory)
+], CurdMixBySysConfigService.prototype, "cacheServiceFactory", void 0);
 CurdMixBySysConfigService = __decorate([
     (0, core_1.Provide)()
 ], CurdMixBySysConfigService);

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

@@ -2,8 +2,9 @@ import { Context } from '@midwayjs/koa';
 import { CurdProService } from './CurdProService';
 import { HandleExecuteContextType, IExecuteContextHandler } from '../../libs/crud-pro/models/ExecuteContext';
 export declare class CurdMixByWorkbenchService implements IExecuteContextHandler {
-    ctx: Context;
+    protected ctx: Context;
     protected curdProService: CurdProService;
+    private cacheServiceFactory;
     private loadWorkbenchListMap;
     handleExecuteContextPrepare(executeContext: HandleExecuteContextType): Promise<void>;
     handleExecuteContext(executeContext: HandleExecuteContextType): Promise<void>;

package/dist/service/curd/CurdMixByWorkbenchService.js

@@ -12,39 +12,43 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CurdMixByWorkbenchService = void 0;
 const core_1 = require("@midwayjs/core");
 const _ = require("lodash");
-const lru_cache_1 = require("lru-cache");
 const CurdProService_1 = require("./CurdProService");
 const CurdMixUtils_1 = require("./CurdMixUtils");
 const SystemTables_1 = require("../../models/SystemTables");
 const keys_1 = require("../../libs/crud-pro/models/keys");
 const MixinUtils_1 = require("../../libs/crud-pro/utils/MixinUtils");
 const global_config_1 = require("../../libs/global-config/global-config");
-const lruCache = new lru_cache_1.LRUCache({
-    max: 500,
-    ttl: 1000 * 60 * 5,
-    ttlAutopurge: true,
-});
+const CacheServiceFactory_1 = require("../base/cache/CacheServiceFactory");
+const SystemEntities_1 = require("../../models/SystemEntities");
 const workbenchMixUtils = new CurdMixUtils_1.CrudMixUtils(CurdMixUtils_1.RelatedType.workbenchBasic);
 const TMP_CTX_KEY = _.uniqueId('CurdMixByWorkbenchService');
+const DEFAULT_CACHE_LEVEL = SystemEntities_1.CacheLevelEnum.MEMORY;
+const DEFAULT_CACHE_SECOND = 60 * 5;
 let CurdMixByWorkbenchService = class CurdMixByWorkbenchService {
     async loadWorkbenchListMap() {
         const { SystemDbName, SystemDbType } = global_config_1.GLOBAL_STATIC_CONFIG.getConfig();
-        let workbenchListMap = lruCache.get('workbenchListMap');
-        if (!workbenchListMap) {
-            const reqJson = {
-                columns: 'workbench_code,workbench_name,workbench_domain',
-                condition: {},
-            };
-            const res = await this.curdProService.executeCrudByCfg(reqJson, {
-                sqlTable: SystemTables_1.SystemTables.sys_workbench,
-                sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY,
-                sqlDatabase: SystemDbName,
-                sqlDbType: SystemDbType,
-            });
-            const workbenchList = res.getResRows();
-            workbenchListMap = MixinUtils_1.MixinUtils.toNewMap(workbenchList, (obj) => obj.workbench_code);
-            lruCache.set('workbenchListMap', workbenchListMap);
-        }
+        const { curdMixByCommonCacheLevel, curdMixByCommonCacheSecond } = this.ctx.workbenchInfoTools.getWorkbenchConfig() || {};
+        const workbenchListMap = await this.cacheServiceFactory.getJsonObjectCache({
+            cacheLevel: curdMixByCommonCacheLevel || DEFAULT_CACHE_LEVEL,
+            cacheSecond: curdMixByCommonCacheSecond || DEFAULT_CACHE_SECOND,
+            cacheKey: 'loadWorkbenchListMap',
+            refreshCache: false,
+            cacheName: SystemEntities_1.CacheNameEnum.CurdMixByWorkbench,
+            getter: async () => {
+                const reqJson = {
+                    columns: 'workbench_code,workbench_name,workbench_domain',
+                    condition: {},
+                };
+                const res = await this.curdProService.executeCrudByCfg(reqJson, {
+                    sqlTable: SystemTables_1.SystemTables.sys_workbench,
+                    sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY,
+                    sqlDatabase: SystemDbName,
+                    sqlDbType: SystemDbType,
+                });
+                const workbenchList = res.getResRows();
+                return MixinUtils_1.MixinUtils.toNewMap(workbenchList, (obj) => obj.workbench_code);
+            },
+        });
         return workbenchListMap;
     }
     async handleExecuteContextPrepare(executeContext) {
@@ -72,6 +76,10 @@ __decorate([
     (0, core_1.Inject)(),
     __metadata("design:type", CurdProService_1.CurdProService)
 ], CurdMixByWorkbenchService.prototype, "curdProService", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", CacheServiceFactory_1.CacheServiceFactory)
+], CurdMixByWorkbenchService.prototype, "cacheServiceFactory", void 0);
 CurdMixByWorkbenchService = __decorate([
     (0, core_1.Provide)()
 ], CurdMixByWorkbenchService);

package/package.json

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

package/src/config/config.default.ts

@@ -164,6 +164,14 @@ export default (appInfo: any) => {
       headerSecret: '222',
     },
 
+    /**
+     * 磁盘缓存配置
+     */
+    fatcmsCache: {
+      diskCacheDir: join(tmpdir(), 'fatcms-disk-cache'),
+      keyPrefix: 'fv1:',
+    },
+
     // 用户会话保持时间，单位秒
     fatcmsUserSessionKeepTimeSecond: 3600 * 24 * 30,
 

package/src/controller/base/BaseApiController.ts

@@ -10,6 +10,9 @@ import { BaseService } from '@/service/base/BaseService';
 import * as moment from 'moment';
 import { CommonException } from '@/libs/crud-pro/exceptions';
 import { RedisKeys } from '@/models/RedisKeys';
+import { Aes128CBC } from 'aes-128-cbc';
+import * as md5 from 'md5';
+import { AsymmetricCrypto } from '@/libs/utils/AsymmetricCrypto';
 
 export interface IExecuteSimpleSqlParams {
   updateCfg?: Record<string, IFuncCfgModel>;
@@ -19,6 +22,11 @@ export interface IExecuteSimpleSqlParams {
   columns?: string | string[]; // ..."columns": "id,name,age,sex,addr",
 }
 
+export interface ISecretBody {
+  secretPayload: string;
+  secretKey: string; // 使用RSA公钥加密的AES密钥
+}
+
 @Controller('/api/BaseApiController')
 export class BaseApiController extends BaseService {
   @Inject()
@@ -167,4 +175,35 @@ export class BaseApiController extends BaseService {
       columnsRelation.push(createdByRelation2);
     }
   }
+
+
+  protected async decodeBodyBySession<T>(body: any): Promise<any> {
+    const sessionInfo = this.getUserSessionInfo();
+    const sessionId = sessionInfo?.sessionId;
+    if (!sessionId) {
+      throw new Error('[decodeBodyBySessionId] sessionId is null');
+    }
+
+    const secretBody = body as ISecretBody;
+
+    if (!secretBody.secretPayload || !secretBody.secretKey) {
+      return body;
+    }
+
+    const { privateKey } = sessionInfo;
+
+    const secretPayload: string = secretBody.secretPayload;
+    const secretKey: string = secretBody.secretKey; // 使用RSA加密的AES密钥  
+    const aesKey = await AsymmetricCrypto.decrypt(privateKey, secretKey); // 解密AES密钥
+
+    const createAes128 = () => {
+      const iv = md5(aesKey + sessionId);
+      return new Aes128CBC(aesKey, iv);
+    }
+    const aes128 = createAes128();
+    const decryptedPayload = await aes128.time_decrypt_base64_utf8(secretPayload);
+    return JSON.parse(decryptedPayload);
+  }
+
+
 }

package/src/controller/gateway/CrudStdGatewayController.ts

@@ -4,13 +4,16 @@ import { BaseApiController } from '../base/BaseApiController';
 import { CrudStdService, SPECIAL_SETTING_KEY, ICrudStdActionParams, IRequestModelCrudProExt } from '@/service/crudstd/CrudStdService';
 import { KeysOfSimpleSQL } from '@/libs/crud-pro/models/keys';
 import { CommonResult } from '@/libs/utils/common-dto';
+import { checkLogin } from '@/middleware/permission.middleware';
 
 type ICrudStdParams = { stdAction: ICrudStdActionParams } & IRequestModelCrudProExt;
 
+
+
 /**
- * 零代码配置的界面，相关的接口的执行
+ * 零代码配置的界面，相关的接口的执行。这里的接口都需要登录。
  */
-@Controller('/ns/gw/api/crudStd')
+@Controller('/ns/gw/api/crudStd', { middleware: [checkLogin()] })
 export class CrudStdGatewayController extends BaseApiController {
   @Inject()
   protected ctx: Context;
@@ -23,18 +26,36 @@ export class CrudStdGatewayController extends BaseApiController {
    */
   @Post('/getParsedCrudStdAppInfo')
   async getParsedCrudStdAppInfo(): Promise<CommonResult> {
-    const body = this.ctx.request.body as ICrudStdParams;
+    const decodeBody = await this.decodeBodyBySession(this.ctx.request.body);
+    const body = decodeBody as ICrudStdParams;
     const appCode = body.stdAction.appCode;
     const parsedAppInfo = await this.crudStdService.getParsedCrudStdAppInfo(appCode);
-    return CommonResult.successNotNull(parsedAppInfo);
+    if (parsedAppInfo) {
+      const parsedAppInfo2: any = { ...parsedAppInfo };
+      delete parsedAppInfo2.created_at;
+      delete parsedAppInfo2.created_by;
+      delete parsedAppInfo2.workbench_code_array;
+      delete parsedAppInfo2.modified_at;
+      delete parsedAppInfo2.modified_by;
+      delete parsedAppInfo2.modified_desc;
+      delete parsedAppInfo2.std_crud_db;
+      delete parsedAppInfo2.std_crud_tbl;
+      return CommonResult.successNotNull(parsedAppInfo2);
+    }
+    return CommonResult.successNotNull(null);
   }
 
+
   /**
    * 列表查询: 分页查询
    */
   @Post('/getObjectList')
   async getObjectList() {
-    const { stdAction, ...otherParams } = this.ctx.request.body as ICrudStdParams;
+
+    const decodeBody = await this.decodeBodyBySession(this.ctx.request.body);
+    const body = decodeBody as ICrudStdParams;
+
+    const { stdAction, ...otherParams } = body;
     stdAction.settingKey = SPECIAL_SETTING_KEY.QUERY_LIST;
     return this.crudStdService.executeStdQuery(stdAction, otherParams, KeysOfSimpleSQL.SIMPLE_QUERY_PAGE);
   }
@@ -44,7 +65,10 @@ export class CrudStdGatewayController extends BaseApiController {
    */
   @Post('/getObjectOne')
   async getObjectOne() {
-    const { stdAction, ...otherParams } = this.ctx.request.body as ICrudStdParams;
+    const decodeBody = await this.decodeBodyBySession(this.ctx.request.body);
+    const body = decodeBody as ICrudStdParams;
+
+    const { stdAction, ...otherParams } = body;
     stdAction.settingKey = SPECIAL_SETTING_KEY.QUERY_ONE;
     return this.crudStdService.executeStdQuery(stdAction, otherParams, KeysOfSimpleSQL.SIMPLE_QUERY_ONE);
   }
@@ -54,7 +78,9 @@ export class CrudStdGatewayController extends BaseApiController {
    */
   @Post('/deleteObject')
   async deleteObject() {
-    const { stdAction, ...otherParams } = this.ctx.request.body as ICrudStdParams;
+    const decodeBody = await this.decodeBodyBySession(this.ctx.request.body);
+    const body = decodeBody as ICrudStdParams;
+    const { stdAction, ...otherParams } = body;
     return this.crudStdService.executeStdQuery(stdAction, otherParams, KeysOfSimpleSQL.SIMPLE_DELETE);
   }
 
@@ -63,7 +89,9 @@ export class CrudStdGatewayController extends BaseApiController {
    */
   @Post('/createObject')
   async createObject() {
-    const { stdAction, ...otherParams } = this.ctx.request.body as ICrudStdParams;
+    const decodeBody = await this.decodeBodyBySession(this.ctx.request.body);
+    const body = decodeBody as ICrudStdParams;
+    const { stdAction, ...otherParams } = body;
     return this.crudStdService.executeStdQuery(stdAction, otherParams, KeysOfSimpleSQL.SIMPLE_INSERT);
   }
 
@@ -72,7 +100,9 @@ export class CrudStdGatewayController extends BaseApiController {
    */
   @Post('/updateObject')
   async updateObject() {
-    const { stdAction, ...otherParams } = this.ctx.request.body as ICrudStdParams;
+    const decodeBody = await this.decodeBodyBySession(this.ctx.request.body);
+    const body = decodeBody as ICrudStdParams;
+    const { stdAction, ...otherParams } = body;
     return this.crudStdService.executeStdQuery(stdAction, otherParams, KeysOfSimpleSQL.SIMPLE_UPDATE);
   }
 
@@ -81,7 +111,9 @@ export class CrudStdGatewayController extends BaseApiController {
    */
   @Post('/executeStdAction')
   async executeStdAction() {
-    const { stdAction, ...otherParams } = this.ctx.request.body as ICrudStdParams;
+    const decodeBody = await this.decodeBodyBySession(this.ctx.request.body);
+    const body = decodeBody as ICrudStdParams;
+    const { stdAction, ...otherParams } = body;
     return await this.crudStdService.executeStdActionByReq(stdAction, otherParams);
   }
 }