midway-fatcms 0.0.1-beta.67 → 0.0.1-beta.68

package/src/service/base/cache/CacheServiceFactory.ts

@@ -1,66 +1,75 @@
 import { Inject, Provide, Config } from '@midwayjs/core';
 import { Context } from '@midwayjs/koa';
-import { ICacheService, IfatcmsCacheConfig } from '@/models/bizmodels';
-import { CacheLevelEnum, CacheNameEnum } from '@/models/SystemEntities';
+import {CacheNameEnum, ICacheService, IfatcmsCacheConfig, IWorkbenchConfigCacheLevel} from '@/models/bizmodels';
+import { CacheLevelEnum,  } from '@/models/SystemEntities';
 import { RedisService } from '@midwayjs/redis';
 import { CtxCache } from './CtxCache';
 import { RedisCache } from './RedisCache';
-import { FatcmsBaseDiskCache } from './DiskCache';
+import { DiskCache } from './DiskCache';
 import { MemoryCache } from './MemoryCache';
 import { NoneCache } from './NoneCache';
 
 interface IGetJsonObjectCacheParam {
-    cacheLevel: CacheLevelEnum;
     cacheName: CacheNameEnum;
     cacheKey: string;
-    cacheSecond: number;
     refreshCache?: boolean;
     getter: () => Promise<any>;
 }
 
+const defaultCacheConfig: IWorkbenchConfigCacheLevel = {
+  cacheLevel: CacheLevelEnum.MEMORY,
+  cacheSecond: 60 * 5
+}
+
 @Provide()
 export class CacheServiceFactory {
-    @Inject()
-    protected ctx: Context;
+  @Inject()
+  protected ctx: Context;
 
-    @Config('fatcmsCache')
-    private fatcmsCache: IfatcmsCacheConfig;
+  @Config('fatcmsCache')
+  private fatcmsCache: IfatcmsCacheConfig;
 
-    @Inject()
-    protected redisService: RedisService;
+  @Inject()
+  protected redisService: RedisService;
 
-    public getCacheService(cacheLevelEnum: CacheLevelEnum, cacheName: CacheNameEnum): ICacheService {
-        switch (cacheLevelEnum) {
-            case CacheLevelEnum.CONTEXT:
-                return new CtxCache(this.ctx, cacheName);
-            case CacheLevelEnum.REDIS:
-                return new RedisCache(this.ctx, cacheName, this.redisService);
-            case CacheLevelEnum.DISK:
-                return new FatcmsBaseDiskCache(this.ctx, cacheName, this.fatcmsCache);
-            case CacheLevelEnum.MEMORY:
-                return new MemoryCache(this.ctx, cacheName);
-            default:
-                return new NoneCache(this.ctx, cacheName);
-        }
+  private getCacheService(cacheLevelEnum: CacheLevelEnum, cacheName: CacheNameEnum, cacheSecond: number): ICacheService {
+    switch (cacheLevelEnum) {
+      case CacheLevelEnum.CONTEXT:
+        return new CtxCache(this.ctx, cacheName);
+      case CacheLevelEnum.REDIS:
+        return new RedisCache(this.ctx, cacheName, this.redisService, cacheSecond);
+      case CacheLevelEnum.DISK:
+        return new DiskCache(this.ctx, cacheName, this.fatcmsCache, cacheSecond);
+      case CacheLevelEnum.MEMORY:
+        return new MemoryCache(this.ctx, cacheName, cacheSecond);
+      case CacheLevelEnum.NONE:
+        return new NoneCache(this.ctx, cacheName);
+      default:
+        return new NoneCache(this.ctx, cacheName);
     }
+  }
 
-    public async getJsonObjectCache(param: IGetJsonObjectCacheParam): Promise<any> {
-        let { cacheLevel, cacheName, cacheKey, cacheSecond, refreshCache, getter } = param;
 
-        if (!cacheSecond || typeof cacheSecond !== 'number') {
-            console.error('[CacheServiceFactory#getJsonObjectCache] cacheSecond is not number, use default value 60, ' + JSON.stringify(param));
-            cacheSecond = 60;
-        }
+  public getCacheServiceByName(cacheName: CacheNameEnum): ICacheService {
+    const cacheConfig: Record<CacheNameEnum, IWorkbenchConfigCacheLevel> = (this.fatcmsCache?.cacheConfig || {}) as any;
+    if (cacheConfig[cacheName]) {
+      const { cacheLevel, cacheSecond } = Object.assign({}, defaultCacheConfig, cacheConfig[cacheName]) ;
+      return this.getCacheService(cacheLevel, cacheName, cacheSecond);
+    }
+    const { cacheLevel, cacheSecond } = defaultCacheConfig;
+    return this.getCacheService(cacheLevel, cacheName, cacheSecond);
+  }
 
-        const realCacheKey = this.fatcmsCache.keyPrefix + cacheKey;
 
-        const cacheService = this.getCacheService(cacheLevel, cacheName);
-        let obj = cacheService.getJsonObject(realCacheKey);
-        if (!obj || refreshCache === true) {
-            obj = await getter();
-            cacheService.setJsonObject(realCacheKey, obj, cacheSecond);
-        }
-        return obj;
+  public async getJsonObjectCache(param: IGetJsonObjectCacheParam): Promise<any> {
+    const {cacheName, cacheKey, refreshCache, getter} = param;
+    const cacheService = this.getCacheServiceByName(cacheName);
+    let obj = await cacheService.getJsonObject(cacheKey);
+    if (!obj || refreshCache === true) {
+      obj = await getter();
+      await cacheService.setJsonObject(cacheKey, obj);
     }
+    return obj;
+  }
 
 }

package/src/service/base/cache/CtxCache.ts

@@ -1,5 +1,5 @@
 import { ICacheService } from '@/models/bizmodels';
-import { CacheNameEnum } from '@/models/SystemEntities';
+import { CacheNameEnum} from "@/models/bizmodels";
 import { Context } from '@midwayjs/koa';
 
 
@@ -7,7 +7,6 @@ import { Context } from '@midwayjs/koa';
 export class CtxCache implements ICacheService {
     private ctx: Context;
     private cacheName: CacheNameEnum;
-
     constructor(ctx: Context, cacheName: CacheNameEnum) {
         this.ctx = ctx;
         this.cacheName = cacheName;
@@ -32,10 +31,9 @@ export class CtxCache implements ICacheService {
      * 设置缓存对象
      * @param key
      * @param obj
-     * @param expireSecond 过期时间，单位秒
      * @returns
      */
-    async setJsonObject(key: string, obj: any, expireSecond?: number): Promise<any> {
+    async setJsonObject(key: string, obj: any): Promise<any> {
         const cacheMap = this.getCacheMap();
         cacheMap.set(key, obj);
     }

package/src/service/base/cache/DiskCache.ts

@@ -7,23 +7,25 @@ import { parseJsonObject } from '@/libs/utils/functions';
 import { ICacheService, IfatcmsCacheConfig } from '@/models/bizmodels';
 
 
-export class FatcmsBaseDiskCache implements ICacheService {
+export class DiskCache implements ICacheService {
     protected ctx: Context;
     protected cacheName: string;
     private fatcmsCache: IfatcmsCacheConfig;
-
-    constructor(ctx: Context, cacheName: string, fatcmsCache: IfatcmsCacheConfig) {
+    private cacheSecond: number;
+    constructor(ctx: Context, cacheName: string, fatcmsCache: IfatcmsCacheConfig,cacheSecond: number) {
         this.ctx = ctx;
         this.cacheName = cacheName;
         this.fatcmsCache = fatcmsCache;
+        this.cacheSecond = cacheSecond;
     }
 
 
-    /**
-     * 获取缓存文件路径
-     * @param key
-     * @returns
-     */
+  /**
+   * 获取缓存文件路径
+   * @param key
+   * @param checkDirExist
+   * @private
+   */
     private async getCacheFilePath(key: string, checkDirExist: boolean = true): Promise<string> {
         const cacheDir0 = this.fatcmsCache.diskCacheDir;
         const cacheDir = path.join(cacheDir0, this.cacheName);
@@ -50,21 +52,14 @@ export class FatcmsBaseDiskCache implements ICacheService {
         }
     }
 
-    /**
-     * 设置缓存对象
-     * @param key
-     * @param obj
-     * @param expireSecond 过期时间，单位秒
-     * @returns
-     */
-    async setJsonObject(key: string, obj: any, expireSecond?: number): Promise<any> {
-        if (!expireSecond) {
-            expireSecond = 60;
-        }
+
+    async setJsonObject(key: string, obj: any, cacheSecond0?: number): Promise<any> {
+      const cacheSecond = cacheSecond0 || this.cacheSecond || 60;
+
         const str = JSON.stringify({
             data: obj,
             key,
-            expireAt: Date.now() + expireSecond * 1000,
+            expireAt: Date.now() + cacheSecond * 1000,
         });
         const cacheFilePath = await this.getCacheFilePath(key);
         try {

package/src/service/base/cache/MemoryCache.ts

@@ -10,16 +10,18 @@ const LRU_CACHE_MAP = new Map<string, LRUCache<string, any>>();
 export class MemoryCache implements ICacheService {
     protected ctx: Context;
     protected cacheName: string;
+    protected cacheSecond: number;
 
-    constructor(ctx: Context, cacheName: string) {
+    constructor(ctx: Context, cacheName: string, cacheSecond:number) {
         this.ctx = ctx;
         this.cacheName = cacheName;
+        this.cacheSecond = cacheSecond;
     }
 
     private getLruCache(): LRUCache<string, any> {
         if (!LRU_CACHE_MAP.has(this.cacheName)) {
             const lruCache = new LRUCache<string, any>({
-                max: 500,
+                max: 2000,
                 ttl: 1000 * 60 * 60 * 24,
                 ttlAutopurge: true,
             });
@@ -41,22 +43,14 @@ export class MemoryCache implements ICacheService {
         }
     }
 
-    /**
-     * 设置缓存对象
-     * @param key
-     * @param obj
-     * @param expireSecond 过期时间，单位秒
-     * @returns
-     */
-    async setJsonObject(key: string, obj: any, expireSecond?: number): Promise<any> {
+
+    async setJsonObject(key: string, obj: any, cacheSecond0: number): Promise<any> {
+        const cacheSecond = cacheSecond0 || this.cacheSecond || 60;
         const lruCache = this.getLruCache();
-        if (!expireSecond) {
-            expireSecond = 60;
-        }
         const saveObj = {
             data: obj,
             key,
-            expireAt: Date.now() + expireSecond * 1000,
+            expireAt: Date.now() + cacheSecond * 1000,
         };
         lruCache.set(key, saveObj);
         return true;

package/src/service/base/cache/RedisCache.ts

@@ -3,16 +3,17 @@ import { RedisService } from '@midwayjs/redis';
 import { parseJsonObject } from '@/libs/utils/functions';
 import { ICacheService } from '@/models/bizmodels';
 
-
 export class RedisCache implements ICacheService {
   protected ctx: Context;
   protected cacheName: string;
   protected redisService: RedisService;
+  protected cacheSecond: number;
 
-  constructor(ctx: Context, cacheName: string, redisService: RedisService) {
+  constructor(ctx: Context, cacheName: string, redisService: RedisService, cacheSecond: number) {
     this.ctx = ctx;
     this.cacheName = cacheName;
     this.redisService = redisService;
+    this.cacheSecond = cacheSecond;
   }
 
   private getCacheKey(key: string): string {
@@ -25,24 +26,16 @@ export class RedisCache implements ICacheService {
     return parseJsonObject(str);
   }
 
-  /**
-   * 设置缓存对象
-   * @param key
-   * @param obj
-   * @param expireSecond 过期时间，单位秒
-   * @returns
-   */
-  async setJsonObject(key: string, obj: any, expireSecond?: number): Promise<any> {
+
+  async setJsonObject(key: string, obj: any, cacheSecond0?: number): Promise<any> {
+    const cacheSecond = cacheSecond0 || this.cacheSecond || 60;
     const cacheKey = this.getCacheKey(key);
-    if (!expireSecond) {
-      expireSecond = 60;
-    }
     const str = JSON.stringify(obj);
-    return this.redisService.set(cacheKey, str, 'EX', expireSecond);
+    return this.redisService.set(cacheKey, str, 'EX', cacheSecond);
   }
 
   async removeItem(key: string): Promise<any> {
     const cacheKey = this.getCacheKey(key);
-    return await this.redisService.del(cacheKey);
+    return this.redisService.del(cacheKey);
   }
 }

package/src/service/crudstd/CrudStdService.ts

@@ -1,24 +1,24 @@
 /* eslint-disable prettier/prettier */
 import * as _ from 'lodash';
 import * as ejs from 'ejs';
-import { Inject, Provide } from '@midwayjs/core';
-import { Context } from '@midwayjs/koa';
-import { CurdMixService } from '../curd/CurdMixService';
-import { IRequestCfgModel, IRequestModel } from '@/libs/crud-pro/interfaces';
-import { KeysOfAuthType, KeysOfSimpleSQL, SqlDbType } from '@/libs/crud-pro/models/keys';
-import { parseJsonObject } from '@/libs/utils/functions';
-import { ICrudStdAppInfo, ICrudStdAppInfoForSettingKey } from '@/models/bizmodels';
-import { BizException } from '@/models/devops';
-import { ExecuteContext } from '@/libs/crud-pro/models/ExecuteContext';
-import { SystemTables } from '@/models/SystemTables';
-import { CrudStdActionService } from './CrudStdActionService';
-import { CrudStdRelationService } from './CrudStdRelationService';
-import { ApiBaseService } from '../base/ApiBaseService';
-import { parseDatabaseName } from '@/libs/crud-pro/utils/DatabaseName';
-import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
-import { MixinUtils } from '@/libs/crud-pro/utils/MixinUtils';
-import { CacheServiceFactory } from '../base/cache/CacheServiceFactory';
-import { CacheLevelEnum, CacheNameEnum } from '@/models/SystemEntities';
+import {Inject, Provide} from '@midwayjs/core';
+import {Context} from '@midwayjs/koa';
+import {CurdMixService} from '../curd/CurdMixService';
+import {IRequestCfgModel, IRequestModel} from '@/libs/crud-pro/interfaces';
+import {KeysOfAuthType, KeysOfSimpleSQL, SqlDbType} from '@/libs/crud-pro/models/keys';
+import {parseJsonObject} from '@/libs/utils/functions';
+import {ICrudStdAppInfo, ICrudStdAppInfoForSettingKey} from '@/models/bizmodels';
+import {BizException} from '@/models/devops';
+import {ExecuteContext} from '@/libs/crud-pro/models/ExecuteContext';
+import {SystemTables} from '@/models/SystemTables';
+import {CrudStdActionService} from './CrudStdActionService';
+import {CrudStdRelationService} from './CrudStdRelationService';
+import {ApiBaseService} from '../base/ApiBaseService';
+import {parseDatabaseName} from '@/libs/crud-pro/utils/DatabaseName';
+import {GLOBAL_STATIC_CONFIG} from '@/libs/global-config/global-config';
+import {MixinUtils} from '@/libs/crud-pro/utils/MixinUtils';
+import {CacheServiceFactory} from '../base/cache/CacheServiceFactory';
+import {CacheNameEnum} from "@/models/bizmodels";
 
 
 export const SPECIAL_SETTING_KEY = {
@@ -38,11 +38,6 @@ export interface IRequestModelCrudProExt extends IRequestModel {
 }
 
 
-
-const DEFAULT_CACHE_LEVEL = CacheLevelEnum.MEMORY;
-const DEFAULT_CACHE_SECOND = 60 * 5;
-
-
 function isNotEmptyStr(str: any): boolean {
   return typeof str === 'string' && str.trim().length > 0;
 }
@@ -315,20 +310,13 @@ export class CrudStdService extends ApiBaseService {
    * @private
    */
   public async getParsedCrudStdAppInfo(appCode: string): Promise<ICrudStdAppInfo> {
-    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,
+    return await this.cacheServiceFactory.getJsonObjectCache({
       cacheKey: appCode,
-      cacheSecond,
       cacheName: CacheNameEnum.GetParsedCrudStdAppInfo,
       getter: async () => {
         return await this.getParsedCrudStdAppInfoPrivate(appCode);
       },
     });
-    return appInfo;
   }
 
 

package/src/service/curd/CurdMixByAccountService.ts

@@ -9,6 +9,8 @@ import { KeysOfSimpleSQL } from '@/libs/crud-pro/models/keys';
 import { ColumnRelation, IRequestCfgModel, IRequestModel } from '@/libs/crud-pro/interfaces';
 import { MixinUtils } from '@/libs/crud-pro/utils/MixinUtils';
 import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
+import { CacheNameEnum} from "@/models/bizmodels";
+import { CacheServiceFactory } from "@/service/base/cache/CacheServiceFactory";
 
 const dictMixUtils = new CrudMixUtils(RelatedType.accountBasic);
 
@@ -17,17 +19,21 @@ const TMP_CTX_KEY2 = _.uniqueId('CurdMixByAccountService2');
 
 
 
+
 @Provide()
 export class CurdMixByAccountService implements IExecuteContextHandler {
-  
+
   @Inject()
   protected ctx: Context;
 
   @Inject()
   protected curdProService: CurdProService;
 
+  @Inject()
+  private cacheServiceFactory: CacheServiceFactory;
+
+
   async handleExecuteContextPrepare(executeContext: HandleExecuteContextType) {
-    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
 
     const relations = dictMixUtils.pickColumnRelations(executeContext);
     if (!relations || relations.length === 0) {
@@ -57,29 +63,71 @@ export class CurdMixByAccountService implements IExecuteContextHandler {
       return;
     }
 
-    const cfgModel: IRequestCfgModel = {
-      method: 'UserAccountService.queryAccountBasicInfoByIds',
-      sqlTable: SystemTables.sys_user_account,
-      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
-      sqlDatabase: SystemDbName,
-      sqlDbType: SystemDbType,
-    };
+    const userInfos = await this.queryUserAccountIdList([...accountIds]);
+    executeContext[TMP_CTX_KEY] = MixinUtils.toNewMap(userInfos, (obj: any) => obj.account_id);
+    executeContext[TMP_CTX_KEY2] = isArrayModeMap;
+  }
+
 
+  private async getFromCache(code: string): Promise<any> {
+    const cacheService = this.cacheServiceFactory.getCacheServiceByName(CacheNameEnum.CurdMixByAccount);
+    return cacheService.getJsonObject(code);
+  }
+
+  private async setToCache(code: string, value: any): Promise<any> {
+    const cacheService = this.cacheServiceFactory.getCacheServiceByName(CacheNameEnum.CurdMixByAccount);
+    return cacheService.setJsonObject(code, value);
+  }
+
+  private async queryUserAccountIdList(accountIds: string[]): Promise<any[]> {
+    const resultRowMap = {} as Record<string, any>;
+    for (let i = 0; i < accountIds.length; i++) {
+      const accountId = accountIds[i];
+      const row = await this.getFromCache(accountId);
+      if (row) {
+        resultRowMap[accountId] = row;
+      }
+    }
+
+    const notCachedCodes = accountIds.filter((accountId) => !resultRowMap[accountId]);
+    if (notCachedCodes.length === 0) {
+      return Object.values(resultRowMap);
+    }
+
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
     const reqJson: IRequestModel = {
       columns: ['nick_name', 'avatar', 'account_id'],
       condition: {
         account_id: {
-          $in: [...accountIds],
+          $in: [...notCachedCodes],
         },
       },
     };
 
+    const cfgModel: IRequestCfgModel = {
+      method: 'UserAccountService.queryAccountBasicInfoByIds',
+      sqlTable: SystemTables.sys_user_account,
+      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
+      sqlDatabase: SystemDbName,
+      sqlDbType: SystemDbType,
+    };
     const res = await this.curdProService.executeCrudByCfg(reqJson, cfgModel);
-    const userInfos = res.getResRows();
-    executeContext[TMP_CTX_KEY] = MixinUtils.toNewMap(userInfos, (obj: any) => obj.account_id);
-    executeContext[TMP_CTX_KEY2] = isArrayModeMap;
+    const rows = res.getResRows();
+    if (Array.isArray(rows) && rows.length > 0) {
+      for (let i = 0; i < rows.length; i++) {
+        const row = rows[i];
+        const { account_id } = row;
+        await this.setToCache(account_id, row);
+        resultRowMap[account_id] = row;
+      }
+    }
+    return Object.values(resultRowMap)
+
   }
 
+
+
+
   async handleExecuteContext(executeContext: HandleExecuteContextType): Promise<void> {
     const userInfoMap = executeContext[TMP_CTX_KEY] as Map<string, any>;
     const isArrayModeMap = executeContext[TMP_CTX_KEY2] as Map<string, boolean>;
@@ -105,7 +153,7 @@ export class CurdMixByAccountService implements IExecuteContextHandler {
             { from: 'avatar', to: `${sourceColumn}_user.avatar` },
             { from: 'account_id', to: `${sourceColumn}_user.account_id` },
           ];
-        } 
+        }
       }
       dictMixUtils.copyUserInfoToRowNoRelatedCode(row, userInfoMap, columnRelation);
     });

package/src/service/curd/CurdMixByDictService.ts

@@ -10,15 +10,12 @@ import { MultiKeyMap } from '@/libs/crud-pro/utils/MultiKeyMap';
 import { ColumnRelation } from '@/libs/crud-pro/interfaces';
 import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
 import { CacheServiceFactory } from '../base/cache/CacheServiceFactory';
-import { CacheLevelEnum, CacheNameEnum } from '@/models/SystemEntities';
+import { CacheNameEnum} from "@/models/bizmodels";
 
 const TMP_CTX_KEY = _.uniqueId('CurdMixByDictService');
 const dictMixUtils = new CrudMixUtils(RelatedType.dict);
 
 
-const DEFAULT_CACHE_LEVEL = CacheLevelEnum.MEMORY;
-const DEFAULT_CACHE_SECOND = 60 * 5;
-
 @Provide()
 export class CurdMixByDictService implements IExecuteContextHandler {
   @Inject()
@@ -30,16 +27,14 @@ export class CurdMixByDictService implements IExecuteContextHandler {
   @Inject()
   private cacheServiceFactory: CacheServiceFactory;
 
-  private async getFromCache(code: string): Promise<any> {
-    const { curdMixByCommonCacheLevel } = this.ctx.workbenchInfoTools.getWorkbenchConfig();
-    const cacheService = this.cacheServiceFactory.getCacheService(curdMixByCommonCacheLevel || DEFAULT_CACHE_LEVEL, CacheNameEnum.CurdMixByDict);
+  private async getFromCache(code: string): Promise<any[]> {
+    const cacheService = this.cacheServiceFactory.getCacheServiceByName(CacheNameEnum.CurdMixByDict);
     return cacheService.getJsonObject(code);
   }
 
-  private async setToCache(code: string, value: any): Promise<any> {
-    const { curdMixByCommonCacheLevel, curdMixByCommonCacheSecond } = this.ctx.workbenchInfoTools.getWorkbenchConfig();
-    const cacheService = this.cacheServiceFactory.getCacheService(curdMixByCommonCacheLevel || DEFAULT_CACHE_LEVEL, CacheNameEnum.CurdMixByDict);
-    return cacheService.setJsonObject(code, value, curdMixByCommonCacheSecond || DEFAULT_CACHE_SECOND);
+  private async setToCache(code: string, value: any[]): Promise<any> {
+    const cacheService = this.cacheServiceFactory.getCacheServiceByName(CacheNameEnum.CurdMixByDict);
+    return cacheService.setJsonObject(code, value);
   }
 
   async handleExecuteContextPrepare(executeContext: HandleExecuteContextType): Promise<void> {

package/src/service/curd/CurdMixByLinkToCustomService.ts

@@ -11,7 +11,7 @@ import { Exceptions } from '@/libs/crud-pro/exceptions';
 import { parseDatabaseName } from '@/libs/crud-pro/utils/DatabaseName';
 import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
 import { IRequestCfgModel2 } from '@/models/bizmodels';
-import { CacheLevelEnum, CacheNameEnum } from '@/models/SystemEntities';
+import { CacheNameEnum} from "@/models/bizmodels";
 import { CacheServiceFactory } from '../base/cache/CacheServiceFactory';
 import * as md5 from 'md5';
 
@@ -19,10 +19,6 @@ const linkToCustomMixUtils = new CrudMixUtils(RelatedType.linkToCustom);
 const TMP_CTX_KEY = _.uniqueId('CurdMixByLinkToCustomService');
 
 
-const DEFAULT_CACHE_LEVEL = CacheLevelEnum.MEMORY;
-const DEFAULT_CACHE_SECOND = 60 * 5;
-
-
 function toMapObject(rows: any[], fieldsArr: string[]): Map<string, any> {
   const valueKey = fieldsArr[0];
   const labelKey = fieldsArr[1];
@@ -98,11 +94,8 @@ export class CurdMixByLinkToCustomService implements IExecuteContextHandler {
   }
 
   public async queryInfoByLinkToCustom(code: string): Promise<Map<string, any>> {
-    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: CacheNameEnum.CurdMixByLinkToCustom,
       getter: async () => {
         return await this.queryInfoByLinkToCustomImpl(code);

package/src/service/curd/CurdMixBySysConfigService.ts

@@ -11,17 +11,12 @@ import { ColumnRelation } from '@/libs/crud-pro/interfaces';
 import { parseConfigContentToEnumInfo } from '@/libs/utils/parseConfig';
 import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
 import { CacheServiceFactory } from '../base/cache/CacheServiceFactory';
-import { CacheLevelEnum, CacheNameEnum } from '@/models/SystemEntities';
+import { CacheNameEnum} from "@/models/bizmodels";
 
 const dictMixUtils = new CrudMixUtils(RelatedType.sysCfgEnum);
 
 const TMP_CTX_KEY = _.uniqueId('CurdMixBySysConfigService');
 
-const DEFAULT_CACHE_LEVEL = CacheLevelEnum.MEMORY;
-const DEFAULT_CACHE_SECOND = 60 * 5;
-
-
-
 
 @Provide()
 export class CurdMixBySysConfigService implements IExecuteContextHandler {
@@ -35,15 +30,13 @@ export class CurdMixBySysConfigService implements IExecuteContextHandler {
 
 
   private async getFromCache(code: string): Promise<any> {
-    const { curdMixByCommonCacheLevel } = this.ctx.workbenchInfoTools.getWorkbenchConfig();
-    const cacheService = this.cacheServiceFactory.getCacheService(curdMixByCommonCacheLevel || DEFAULT_CACHE_LEVEL, CacheNameEnum.CurdMixBySysConfig);
+    const cacheService = this.cacheServiceFactory.getCacheServiceByName(CacheNameEnum.CurdMixBySysConfig);
     return cacheService.getJsonObject(code);
   }
 
   private async setToCache(code: string, value: any): Promise<any> {
-    const { curdMixByCommonCacheLevel, curdMixByCommonCacheSecond } = this.ctx.workbenchInfoTools.getWorkbenchConfig();
-    const cacheService = this.cacheServiceFactory.getCacheService(curdMixByCommonCacheLevel || DEFAULT_CACHE_LEVEL, CacheNameEnum.CurdMixBySysConfig);
-    return cacheService.setJsonObject(code, value, curdMixByCommonCacheSecond || DEFAULT_CACHE_SECOND);
+    const cacheService = this.cacheServiceFactory.getCacheServiceByName(CacheNameEnum.CurdMixBySysConfig);
+    return cacheService.setJsonObject(code, value);
   }
 
 
@@ -63,10 +56,10 @@ export class CurdMixBySysConfigService implements IExecuteContextHandler {
       return Object.values(resultRowMap);
     }
 
-    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+    const {SystemDbName, SystemDbType} = GLOBAL_STATIC_CONFIG.getConfig();
     const res1 = await this.curdProService.executeCrudByCfg(
       {
-        condition: { config_code: { $in: notCachedCodes } },
+        condition: {config_code: {$in: notCachedCodes}},
       },
       {
         sqlTable: SystemTables.sys_configs,
@@ -79,12 +72,12 @@ export class CurdMixBySysConfigService implements IExecuteContextHandler {
     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_code} = row;
         await this.setToCache(config_code, row);
         resultRowMap[config_code] = row;
       }
     }
-return Object.values(resultRowMap)
+    return Object.values(resultRowMap)
   }
 
   async handleExecuteContextPrepare(executeContext: HandleExecuteContextType) {