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

package/src/service/SysAppService.ts

@@ -0,0 +1,88 @@
+import {Inject, Provide} from '@midwayjs/core';
+import {SystemTables} from '@/models/SystemTables';
+import {BaseService} from './base/BaseService';
+import {CurdProService} from './curd/CurdProService';
+import {GLOBAL_STATIC_CONFIG} from '@/libs/global-config/global-config';
+import {CacheServiceFactory} from "@/service/base/cache/CacheServiceFactory";
+import {CacheNameEnum} from "@/models/bizmodels";
+
+@Provide()
+export class SysAppService extends BaseService {
+
+  @Inject()
+  private curdProService: CurdProService;
+
+  @Inject()
+  private cacheServiceFactory: CacheServiceFactory;
+
+  private get sysAppDao(){
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+    return this.curdProService.getBbUtil(SystemDbName, SystemDbType, SystemTables.sys_app)
+  }
+
+  private get sysAppPageDao(){
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+    return this.curdProService.getBbUtil(SystemDbName, SystemDbType, SystemTables.sys_app_page)
+  }
+
+
+  async getSysAppPageOne({page_path,workbench_code}:{page_path: string,workbench_code: string}): Promise<any> {
+    if (!page_path || typeof page_path !== 'string') {
+      throw new Error('[getSysAppPageOne] page_path required');
+    }
+    if (!workbench_code || typeof workbench_code !== 'string') {
+      throw new Error('[getSysAppPageOne] workbench_code required');
+    }
+    return await this.cacheServiceFactory.getJsonObjectCache({
+      cacheKey: `${workbench_code}#${page_path}`,
+      cacheName: CacheNameEnum.GetSysAppPageOne,
+      getter: async () => {
+        return await this.sysAppPageDao.getUniqueOne({
+          condition: {page_path, workbench_code, deleted_at: 0}
+        });
+      },
+    });
+  }
+
+
+  async getSysAppOne(app_code: string): Promise<any> {
+    if (!app_code || typeof app_code !== 'string') {
+      throw new Error('[getSysAppOne] app_code required');
+    }
+    return await this.cacheServiceFactory.getJsonObjectCache({
+      cacheKey: app_code,
+      cacheName: CacheNameEnum.GetSysAppOne,
+      getter: async () => {
+        return await this.sysAppDao.getUniqueOne({
+          condition: {app_code, deleted_at: 0}
+        });
+      },
+    });
+  }
+
+  public deletePrivateField(parsedAppInfo: any){
+    if (!parsedAppInfo) {
+      return null;
+    }
+    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 parsedAppInfo2;
+  }
+
+  async removeSysAppOneCache(app_code: string) {
+    if (!app_code || typeof app_code !== 'string') {
+      throw new Error('[removeSysAppOneCache] app_code required');
+    }
+    return await this.cacheServiceFactory.removeItemCache({
+      cacheKey: app_code,
+      cacheName: CacheNameEnum.GetSysAppOne
+    });
+  }
+}

package/src/service/SysConfigService.ts

@@ -1,10 +1,11 @@
 import { Inject, Provide } from '@midwayjs/core';
 import { Context } from '@midwayjs/koa';
-import { KeysOfSimpleSQL } from '@/libs/crud-pro/models/keys';
 import { SystemTables } from '@/models/SystemTables';
 import { BaseService } from './base/BaseService';
 import { CurdProService } from './curd/CurdProService';
 import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
+import { CacheNameEnum } from "@/models/bizmodels";
+import { CacheServiceFactory } from "@/service/base/cache/CacheServiceFactory";
 
 @Provide()
 export class SysConfigService extends BaseService {
@@ -14,24 +15,37 @@ export class SysConfigService extends BaseService {
   @Inject()
   private curdProService: CurdProService;
 
-  async getSysConfigOne(config_code: string): Promise<any> {
-    if (!config_code) {
-      throw new Error('[getSysConfigOne] config_code required');
-    }
+  @Inject()
+  private cacheServiceFactory: CacheServiceFactory;
 
+  private get sysConfigsDao(){
     const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+    return this.curdProService.getBbUtil(SystemDbName, SystemDbType, SystemTables.sys_configs)
+  }
 
-    const res1 = await this.curdProService.executeCrudByCfg(
-      {
-        condition: { config_code },
+  async getSysConfigOne(config_code: string): Promise<any> {
+    if (!config_code || typeof config_code !== 'string') {
+      throw new Error('[getSysAppOne] config_code required');
+    }
+    return await this.cacheServiceFactory.getJsonObjectCache({
+      cacheKey: config_code,
+      cacheName: CacheNameEnum.GetSysConfigOne,
+      getter: async () => {
+        return await this.sysConfigsDao.getUniqueOne({
+          condition: {config_code, deleted_at: 0}
+        });
       },
-      {
-        sqlTable: SystemTables.sys_configs,
-        sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY_ONE,
-        sqlDatabase: SystemDbName,
-        sqlDbType: SystemDbType,
-      }
-    );
-    return res1.getOneObj();
+    });
+  }
+
+  async removeSysConfigOneCache(config_code: string) {
+    if (!config_code || typeof config_code !== 'string') {
+      throw new Error('[removeSysConfigOneCache] config_code required');
+    }
+
+    return await this.cacheServiceFactory.removeItemCache({
+      cacheKey: config_code,
+      cacheName: CacheNameEnum.GetSysConfigOne,
+    });
   }
 }

package/src/service/WorkbenchService.ts

@@ -1,30 +1,27 @@
-import { Inject, Provide, Config } from '@midwayjs/core';
-import { Context } from '@midwayjs/koa';
-import { KeysOfSimpleSQL } from '@/libs/crud-pro/models/keys';
-import { SystemTables } from '@/models/SystemTables';
-import { BaseService } from './base/BaseService';
+import {Config, Inject, Provide} from '@midwayjs/core';
+import {Context} from '@midwayjs/koa';
+import {KeysOfSimpleSQL} from '@/libs/crud-pro/models/keys';
+import {SystemTables} from '@/models/SystemTables';
+import {BaseService} from './base/BaseService';
 // import { LRUCache } from 'lru-cache';
-import { CurdProService } from './curd/CurdProService';
-import { CommonException } from '@/libs/crud-pro/exceptions';
-import { parseJsonObject } from '@/libs/utils/functions';
-import { IWorkbenchConfig, IWorkbenchEntity } from '@/models/SystemEntities';
-import { IScheduleService } from '@/interface';
-import { getDebugWorkbenchCode } from '@/libs/utils/fatcms-request';
-import { MixinUtils } from '@/libs/crud-pro/utils/MixinUtils';
-import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
-import { HEADER_KEY_RUN_BY_ASYNC_TASK_WORKBENCH_CODE } from '@/models/AsyncTaskModel';
-import { formatHost } from '@/libs/utils/format-url';
-//
-// const lruCache = new LRUCache<string, any>({
-//   max: 500,
-//   ttl: 1000 * 60 * 60,
-//   ttlAutopurge: true,
-// });
-
-const lruCache = new Map<string, any>();
-
-const CACHE_KEY_WORKBENCH_LIST = 'CACHE_KEY_WORKBENCH_LIST';
-const CACHE_KEY_DOMAIN_MAP = 'CACHE_KEY_DOMAIN_MAP';
+import {CurdProService} from './curd/CurdProService';
+import {CommonException} from '@/libs/crud-pro/exceptions';
+import {parseJsonObject} from '@/libs/utils/functions';
+import {IWorkbenchConfig, IWorkbenchEntity} from '@/models/SystemEntities';
+import {IScheduleService} from '@/interface';
+import {getDebugWorkbenchCode} from '@/libs/utils/fatcms-request';
+import {MixinUtils} from '@/libs/crud-pro/utils/MixinUtils';
+import {GLOBAL_STATIC_CONFIG} from '@/libs/global-config/global-config';
+import {HEADER_KEY_RUN_BY_ASYNC_TASK_WORKBENCH_CODE} from '@/models/AsyncTaskModel';
+import {formatHost} from '@/libs/utils/format-url';
+import {CacheServiceFactory} from "@/service/base/cache/CacheServiceFactory";
+import {CacheNameEnum} from "@/models/bizmodels";
+
+
+interface IWorkbenchCachedObj {
+  workbenchList: IWorkbenchEntity[];
+  workbenchDomainMap: Record<string, IWorkbenchEntity>; // key是domain
+}
 
 @Provide()
 export class WorkbenchService extends BaseService implements IScheduleService {
@@ -34,58 +31,74 @@ export class WorkbenchService extends BaseService implements IScheduleService {
   @Inject()
   private curdProService: CurdProService;
 
+  @Inject()
+  private cacheServiceFactory: CacheServiceFactory;
+
   @Config('fatcmsTargetWorkbenchCode')
   private fatcmsTargetWorkbenchCode: string;
 
-  public clearCache() {
-    lruCache.set(CACHE_KEY_WORKBENCH_LIST, null);
-    lruCache.set(CACHE_KEY_DOMAIN_MAP, null);
+  public async clearCache() {
+
+    await this.cacheServiceFactory.removeItemCache({
+      cacheKey: CacheNameEnum.CurdMixByWorkbench,
+      cacheName: CacheNameEnum.CurdMixByWorkbench,
+    });
+
+    await this.cacheServiceFactory.removeItemCache({
+      cacheKey: CacheNameEnum.GetWorkbenchCachedObj,
+      cacheName: CacheNameEnum.GetWorkbenchCachedObj,
+    });
   }
 
   public async runBySchedule() {
-    await this.getAllWorkbenchInfoMap(true);
+    await this.getWorkbenchCachedObj(true);
+  }
+
+  private async getWorkbenchCachedObj(isForceRefresh?: boolean): Promise<IWorkbenchCachedObj> {
+    return this.cacheServiceFactory.getJsonObjectCache({
+      cacheKey: CacheNameEnum.GetWorkbenchCachedObj,
+      cacheName: CacheNameEnum.GetWorkbenchCachedObj,
+      refreshCache: isForceRefresh,
+      getter: async () => {
+        const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+        const reqJson = { condition: {}, pageSize: 1000, limit: 1000 };
+        const res = await this.curdProService.executeCrudByCfg(reqJson, {
+          sqlTable: SystemTables.sys_workbench,
+          sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
+          sqlDatabase: SystemDbName,
+          sqlDbType: SystemDbType,
+        });
+        const listData =  res.getResRows();
+
+        const domainMap1 = MixinUtils.toMap(listData, (e: any) => e.workbench_domain); // 主域名。其他两个域名。
+        const domainMap2 = MixinUtils.toMap(listData, (e: any) => e.workbench_domain2);
+        const domainMap3 = MixinUtils.toMap(listData, (e: any) => e.workbench_domain3);
+        const domainMap = {...domainMap1, ...domainMap2, ...domainMap3};
+        const cacheObj:IWorkbenchCachedObj =  {
+          workbenchList: listData,
+          workbenchDomainMap: domainMap
+        }
+        return cacheObj;
+      },
+    });
   }
 
   /**
    * 获取所有站点列表
-   * @param isForceRefresh 是否强制刷新缓存
    * @returns
    */
-  public async getAllWorkbenchInfoList(isForceRefresh?: boolean): Promise<IWorkbenchEntity[]> {
-    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
-
-    let listData = lruCache.get(CACHE_KEY_WORKBENCH_LIST);
-    if (!listData || isForceRefresh === true) {
-      const reqJson = { condition: {}, pageSize: 1000, limit: 1000 };
-      const res = await this.curdProService.executeCrudByCfg(reqJson, {
-        sqlTable: SystemTables.sys_workbench,
-        sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
-        sqlDatabase: SystemDbName,
-        sqlDbType: SystemDbType,
-      });
-      listData = res.getResRows();
-      lruCache.set(CACHE_KEY_WORKBENCH_LIST, listData);
-    }
-    return listData;
+  public async getAllWorkbenchInfoList(): Promise<IWorkbenchEntity[]> {
+    const cachedObj = await this.getWorkbenchCachedObj();
+    return cachedObj.workbenchList;
   }
 
   /**
    * 获取所有站点列表，以map的形式返回。其中key为站点域名，value为站点信息
-   * @param isForceRefresh 是否强制刷新缓存
    * @returns
    */
-  public async getAllWorkbenchInfoMap(isForceRefresh?: boolean): Promise<Record<any, IWorkbenchEntity>> {
-    let listData: any[];
-    let domainMap = lruCache.get(CACHE_KEY_DOMAIN_MAP);
-    if (!domainMap || isForceRefresh === true) {
-      listData = await this.getAllWorkbenchInfoList(isForceRefresh);
-      const domainMap1 = MixinUtils.toMap(listData, (e: any) => e.workbench_domain); // 主域名。其他两个域名。
-      const domainMap2 = MixinUtils.toMap(listData, (e: any) => e.workbench_domain2);
-      const domainMap3 = MixinUtils.toMap(listData, (e: any) => e.workbench_domain3);
-      domainMap = { ...domainMap1, ...domainMap2, ...domainMap3 };
-      lruCache.set(CACHE_KEY_DOMAIN_MAP, domainMap);
-    }
-    return domainMap;
+  public async getAllWorkbenchInfoMap(): Promise<Record<string, IWorkbenchEntity>> {
+    const cachedObj = await this.getWorkbenchCachedObj();
+    return cachedObj.workbenchDomainMap;
   }
 
   /**
@@ -222,7 +235,11 @@ export class WorkbenchService extends BaseService implements IScheduleService {
   }
 
 
-
+  /**
+   * 根据站点，配置接口报名单模式
+   * @param workbenchInfo
+   * @param path
+   */
   public isSupportTheNodePathByWorkbenchInfo(workbenchInfo: IWorkbenchEntity, path: string): boolean {
 
     // 非node api路径，直接返回true

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

@@ -16,9 +16,14 @@ interface IGetJsonObjectCacheParam {
     getter: () => Promise<any>;
 }
 
+interface IRemoveItemCacheParam {
+  cacheName: CacheNameEnum;
+  cacheKey: string;
+}
+
 const defaultCacheConfig: IWorkbenchConfigCacheLevel = {
   cacheLevel: CacheLevelEnum.MEMORY,
-  cacheSecond: 60 * 5
+  cacheSecond: 60 * 60 * 24 * 7
 }
 
 @Provide()
@@ -72,4 +77,10 @@ export class CacheServiceFactory {
     return obj;
   }
 
+  public async removeItemCache(param: IRemoveItemCacheParam): Promise<any> {
+    const {cacheName, cacheKey } = param;
+    const cacheService = this.getCacheServiceByName(cacheName);
+    return await cacheService.removeItem(cacheKey);
+  }
+
 }

package/src/service/crudstd/CrudStdService.ts

@@ -10,15 +10,13 @@ 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";
+import {SysAppService} from "@/service/SysAppService";
 
 
 export const SPECIAL_SETTING_KEY = {
@@ -87,7 +85,9 @@ export class CrudStdService extends ApiBaseService {
   protected crudStdRelationService: CrudStdRelationService;
 
   @Inject()
-  protected cacheServiceFactory: CacheServiceFactory;
+  protected sysAppService: SysAppService;
+
+
 
   /**
    * 执行普通CRUD
@@ -284,25 +284,6 @@ export class CrudStdService extends ApiBaseService {
     return this.crudStdActionService.handleStdActionByReq({ appInfo, params, actionsMap, actionCfg });
   }
 
-  /**
-   * 查询APP信息
-   * @param appCode
-   * @private
-   */
-  private async getCrudStdAppInfo(appCode?: string) {
-    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
-
-    this.logInfo('getCrudStdAppInfo', appCode);
-
-    const ss = {
-      sqlTable: SystemTables.sys_app,
-      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY_ONE,
-      sqlDatabase: SystemDbName,
-      sqlDbType: SystemDbType,
-    };
-    return await this.curdMixService.executeCrudByCfg({ condition: { app_code: appCode } }, ss);
-  }
-
 
   /**
    * 查询APP信息
@@ -310,28 +291,11 @@ export class CrudStdService extends ApiBaseService {
    * @private
    */
   public async getParsedCrudStdAppInfo(appCode: string): Promise<ICrudStdAppInfo> {
-    return await this.cacheServiceFactory.getJsonObjectCache({
-      cacheKey: appCode,
-      cacheName: CacheNameEnum.GetParsedCrudStdAppInfo,
-      getter: async () => {
-        return await this.getParsedCrudStdAppInfoPrivate(appCode);
-      },
-    });
-  }
-
-
-  /**
-   * 查询APP信息
-   * @param appCode
-   * @private
-   */
-  private async getParsedCrudStdAppInfoPrivate(appCode: string): Promise<ICrudStdAppInfo> {
-    const a = await this.getCrudStdAppInfo(appCode);
-    const { row } = a.getResModel();
-    if (!row) {
+    const appInfo = await this.sysAppService.getSysAppOne(appCode);
+    if (!appInfo) {
       return null;
     }
-    const { app_schema, ...others } = row;
+    const { app_schema, ...others } = appInfo;
     const stdCrudCfgObj = parseJsonObject(app_schema);
 
     const handleArrayCfg = (arrayCfg: any[]) => {

package/src/service/curd/CrudProQuick.ts

@@ -51,7 +51,7 @@ export class CrudProQuick {
    * @deprecated
    * @param reqJson
    * @param sqlTable
-   * @returns
+   * @returns 返回一条数据对象
    */
   public async getOne(reqJson: IRequestModel, sqlTable?: string): Promise<any> {
     const cfgModel: IRequestCfgModel = {
@@ -66,7 +66,7 @@ export class CrudProQuick {
    * 期望获取唯一的一个对象，如果数据库中的数量不唯一，则报错。
    * @param reqJson
    * @param sqlTable
-   * @returns
+   * @returns 返回一条数据对象
    */
   public async getUniqueOne(reqJson: IRequestModel, sqlTable?: string): Promise<any> {
     const cfgModel: IRequestCfgModel = {
@@ -92,7 +92,7 @@ export class CrudProQuick {
    * 获取数据列表
    * @param reqJson
    * @param sqlTable 数据库表名称
-   * @returns
+   * @returns 返回多条数据对象组成的数组
    */
   public async getList(reqJson: IRequestModel, sqlTable?: string): Promise<any[]> {
     const cfgModel: IRequestCfgModel = {
@@ -167,4 +167,23 @@ export class CrudProQuick {
     };
     return await this.curdPro.executeSQL(sqlCfgModel);
   }
+
+
+  /**
+   * 执行数据库的原生SQL语句，不做任何封装的SQL
+   * @param executeNativeSql
+   * @param args
+   */
+  public async executeNativeSQL(executeNativeSql: string, args?: any[]): Promise<any> {
+    const sqlCfgModel: ISqlCfgModel = {
+      isNativeSQL: true,
+      executeSql: executeNativeSql,
+      executeSqlArgs: args,
+      sqlDatabase: this.sqlDatabase,
+      sqlDbType: this.sqlDbType,
+      maxLimit: this.baseCfgModel.maxLimit || DEFAULT_MAX_LIMIT,
+    };
+    return await this.curdPro.executeSQL(sqlCfgModel);
+  }
+
 }

package/src/service/curd/CurdMixByAccountService.ts

@@ -69,14 +69,14 @@ export class CurdMixByAccountService implements IExecuteContextHandler {
   }
 
 
-  private async getFromCache(code: string): Promise<any> {
+  private async getFromCache(accountId: string): Promise<any> {
     const cacheService = this.cacheServiceFactory.getCacheServiceByName(CacheNameEnum.CurdMixByAccount);
-    return cacheService.getJsonObject(code);
+    return cacheService.getJsonObject(accountId);
   }
 
-  private async setToCache(code: string, value: any): Promise<any> {
+  private async setToCache(accountId: string, value: any): Promise<any> {
     const cacheService = this.cacheServiceFactory.getCacheServiceByName(CacheNameEnum.CurdMixByAccount);
-    return cacheService.setJsonObject(code, value);
+    return cacheService.setJsonObject(accountId, value);
   }
 
   private async queryUserAccountIdList(accountIds: string[]): Promise<any[]> {

package/src/service/curd/CurdMixBySysConfigService.ts

@@ -25,17 +25,18 @@ export class CurdMixBySysConfigService implements IExecuteContextHandler {
 
   @Inject()
   protected curdProService: CurdProService;
+
   @Inject()
   private cacheServiceFactory: CacheServiceFactory;
 
 
   private async getFromCache(code: string): Promise<any> {
-    const cacheService = this.cacheServiceFactory.getCacheServiceByName(CacheNameEnum.CurdMixBySysConfig);
+    const cacheService = this.cacheServiceFactory.getCacheServiceByName(CacheNameEnum.GetSysConfigOne);
     return cacheService.getJsonObject(code);
   }
 
   private async setToCache(code: string, value: any): Promise<any> {
-    const cacheService = this.cacheServiceFactory.getCacheServiceByName(CacheNameEnum.CurdMixBySysConfig);
+    const cacheService = this.cacheServiceFactory.getCacheServiceByName(CacheNameEnum.GetSysConfigOne);
     return cacheService.setJsonObject(code, value);
   }
 

package/src/service/curd/CurdMixByWorkbenchService.ts

@@ -31,9 +31,9 @@ export class CurdMixByWorkbenchService implements IExecuteContextHandler {
   private async loadWorkbenchListMap(): Promise<Map<string, any>> {
     const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
     return await this.cacheServiceFactory.getJsonObjectCache({
-      cacheKey: 'loadWorkbenchListMap',
-      refreshCache: false,
+      cacheKey: CacheNameEnum.CurdMixByWorkbench,
       cacheName: CacheNameEnum.CurdMixByWorkbench,
+      refreshCache: false,
       getter: async () => {
         const reqJson = {
           columns: 'workbench_code,workbench_name,workbench_domain',