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

package/src/service/UserSessionService.ts

@@ -1,15 +1,14 @@
-import { Config, Inject, Provide } from '@midwayjs/core';
-import { Context } from '@midwayjs/koa';
-import { parseJsonObject } from '@/libs/utils/functions';
-import { ISessionInfo, SESSION_ID_KEY, sessionCookieCfg } from '@/models/userSession';
-import { HEADER_KEY_RUN_BY_ASYNC_TASK_ID } from '@/models/AsyncTaskModel';
-import { CurdProService } from './curd/CurdProService';
-import { KeysOfSimpleSQL } from '@/libs/crud-pro/models/keys';
-import { SystemTables } from '@/models/SystemTables';
-import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
-import { CacheServiceFactory } from './base/cache/CacheServiceFactory';
-import { CacheLevelEnum, CacheNameEnum } from '@/models/SystemEntities';
-import { ICacheServiceBase } from '@/models/bizmodels';
+import {Config, Inject, Provide} from '@midwayjs/core';
+import {Context} from '@midwayjs/koa';
+import {parseJsonObject} from '@/libs/utils/functions';
+import {ISessionInfo, SESSION_ID_KEY, sessionCookieCfg} from '@/models/userSession';
+import {HEADER_KEY_RUN_BY_ASYNC_TASK_ID} from '@/models/AsyncTaskModel';
+import {CurdProService} from './curd/CurdProService';
+import {KeysOfSimpleSQL} from '@/libs/crud-pro/models/keys';
+import {SystemTables} from '@/models/SystemTables';
+import {GLOBAL_STATIC_CONFIG} from '@/libs/global-config/global-config';
+import {CacheServiceFactory} from './base/cache/CacheServiceFactory';
+import {ICacheService , CacheNameEnum} from '@/models/bizmodels';
 
 function pickUserAvatar(avatar: any): string {
   if (!avatar) {
@@ -70,8 +69,8 @@ export class UserSessionService {
    * 获取用户会话缓存服务
    * @returns
    */
-  private getUserSessionCacheService(): ICacheServiceBase {
-    return this.cacheServiceFactory.getCacheService(CacheLevelEnum.REDIS, CacheNameEnum.UserSessionBySessionId);
+  private getUserSessionCacheService(): ICacheService {
+    return this.cacheServiceFactory.getCacheServiceByName(CacheNameEnum.UserSessionBySessionId);
   }
 
   /**
@@ -140,15 +139,11 @@ export class UserSessionService {
       return parseJsonObject(asyncTaskObj.created_user_session);
     };
 
-    const sessionInfo1 = await this.cacheServiceFactory.getJsonObjectCache({
-      cacheLevel: CacheLevelEnum.REDIS,
+    return await this.cacheServiceFactory.getJsonObjectCache({
       cacheName: CacheNameEnum.UserSessionByAsyncTaskId,
       cacheKey: taskSessionCacheKey,
-      cacheSecond: 3600,
       getter: loadSessionInfo,
     });
-
-    return sessionInfo1;
   }
 
   /**

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

@@ -1,66 +1,75 @@
 import { Inject, Provide, Config } from '@midwayjs/core';
 import { Context } from '@midwayjs/koa';
-import { ICacheServiceBase, 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 { FatcmsBaseCtxCache } from './FatcmsBaseCtxCache';
-import { FatcmsBaseRedisCache } from './FatcmsBaseRedisCache';
-import { FatcmsBaseDiskCache } from './FatcmsBaseDiskCache';
-import { FatcmsBaseMemoryCache } from './FatcmsBaseMemoryCache';
-import { FatcmsBaseNoneCache } from './FatcmsBaseNoneCache';
+import { CtxCache } from './CtxCache';
+import { RedisCache } from './RedisCache';
+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): ICacheServiceBase {
-        switch (cacheLevelEnum) {
-            case CacheLevelEnum.CONTEXT:
-                return new FatcmsBaseCtxCache(this.ctx, cacheName);
-            case CacheLevelEnum.REDIS:
-                return new FatcmsBaseRedisCache(this.ctx, cacheName, this.redisService);
-            case CacheLevelEnum.DISK:
-                return new FatcmsBaseDiskCache(this.ctx, cacheName, this.fatcmsCache);
-            case CacheLevelEnum.MEMORY:
-                return new FatcmsBaseMemoryCache(this.ctx, cacheName);
-            default:
-                return new FatcmsBaseNoneCache(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/{FatcmsBaseCtxCache.ts → CtxCache.ts}

@@ -1,13 +1,12 @@
-import { ICacheServiceBase } from '@/models/bizmodels';
-import { CacheNameEnum } from '@/models/SystemEntities';
+import { ICacheService } from '@/models/bizmodels';
+import { CacheNameEnum} from "@/models/bizmodels";
 import { Context } from '@midwayjs/koa';
 
 
 
-export class FatcmsBaseCtxCache implements ICacheServiceBase {
+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 FatcmsBaseCtxCache implements ICacheServiceBase {
      * 设置缓存对象
      * @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/{FatcmsBaseDiskCache.ts → DiskCache.ts}

@@ -3,34 +3,36 @@ import * as md5 from 'md5';
 import * as fs from 'fs/promises';
 import * as fs2 from 'fs';
 import * as path from 'path';
-import { parseJsonObject } from '../../../libs/utils/functions';
-import { ICacheServiceBase, IfatcmsCacheConfig } from '@/models/bizmodels';
+import { parseJsonObject } from '@/libs/utils/functions';
+import { ICacheService, IfatcmsCacheConfig } from '@/models/bizmodels';
 
 
-export class FatcmsBaseDiskCache implements ICacheServiceBase {
+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);
         if (checkDirExist) {
             const isDirExist = await fs2.promises.access(cacheDir).then(() => true, () => false);
             if (!isDirExist) {
-                await fs2.promises.mkdir(cacheDir, { recursive: true });    
+                await fs2.promises.mkdir(cacheDir, { recursive: true });
             }
         }
         return path.join(cacheDir, `${md5(key)}.json`);
@@ -50,21 +52,14 @@ export class FatcmsBaseDiskCache implements ICacheServiceBase {
         }
     }
 
-    /**
-     * 设置缓存对象
-     * @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/{FatcmsBaseMemoryCache.ts → MemoryCache.ts}

@@ -1,25 +1,27 @@
 import { Context } from '@midwayjs/koa';
 import { LRUCache } from 'lru-cache';
-import { ICacheServiceBase } from '@/models/bizmodels';
+import { ICacheService } from '@/models/bizmodels';
 
 
 
 const LRU_CACHE_MAP = new Map<string, LRUCache<string, any>>();
 
 
-export class FatcmsBaseMemoryCache implements ICacheServiceBase {
+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 FatcmsBaseMemoryCache implements ICacheServiceBase {
         }
     }
 
-    /**
-     * 设置缓存对象
-     * @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/{FatcmsBaseNoneCache.ts → NoneCache.ts}

@@ -1,10 +1,10 @@
-import { ICacheServiceBase } from '@/models/bizmodels';
+import { ICacheService } from '@/models/bizmodels';
 import { Context } from '@midwayjs/koa';
 
-export class FatcmsBaseNoneCache implements ICacheServiceBase {
+export class NoneCache implements ICacheService {
     protected ctx: Context;
     protected cacheName: string;
-   
+
     constructor(ctx: Context, cacheName: string) {
         this.ctx = ctx;
         this.cacheName = cacheName;

package/src/service/base/cache/{FatcmsBaseRedisCache.ts → RedisCache.ts}

@@ -1,18 +1,19 @@
 import { Context } from '@midwayjs/koa';
 import { RedisService } from '@midwayjs/redis';
-import { parseJsonObject } from '../../../libs/utils/functions';
-import { ICacheServiceBase } from '@/models/bizmodels';
+import { parseJsonObject } from '@/libs/utils/functions';
+import { ICacheService } from '@/models/bizmodels';
 
-
-export class FatcmsBaseRedisCache implements ICacheServiceBase {
+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 FatcmsBaseRedisCache implements ICacheServiceBase {
     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> {