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

package/src/service/curd/CrudProQuick.ts

@@ -0,0 +1,189 @@
+import { KeysOfSimpleSQL, SqlDbType } from '@/libs/crud-pro/models/keys';
+import { IRequestCfgModel, IRequestModel, ISqlCfgModel } from '@/libs/crud-pro/interfaces';
+import { IRequestCfgModel2 } from '@/models/bizmodels';
+import { CrudPro } from '@/libs/crud-pro/CrudPro';
+import { ResModelAffected, ResModelStandard } from '@/libs/crud-pro/models/ResModel';
+
+const DEFAULT_MAX_LIMIT = 10 * 10000;
+
+export class CrudProQuick {
+  private readonly curdPro: CrudPro;
+  private readonly sqlDbType: SqlDbType;
+  private readonly sqlDatabase: string;
+  private readonly sqlTable?: string;
+  private baseCfgModel: IRequestCfgModel2 = {
+    maxLimit: DEFAULT_MAX_LIMIT,
+  };
+
+  constructor(curdPro: CrudPro, sqlDatabase: string, sqlDbType: SqlDbType, sqlTable?: string) {
+    this.sqlDatabase = sqlDatabase;
+    this.sqlDbType = sqlDbType;
+    this.curdPro = curdPro;
+    this.sqlTable = sqlTable; // 全局sqlTable为空时，单独调用时就必须传sqlTable参数。
+  }
+
+  public setBaseCfgModel(baseCfgModel: IRequestCfgModel2) {
+    Object.assign(this.baseCfgModel, baseCfgModel);
+  }
+
+  private async executeCrudByCfg(reqJson: IRequestModel, cfgModel2: IRequestCfgModel2) {
+    const cfgModel = { ...this.baseCfgModel };
+    Object.assign(cfgModel, cfgModel2);
+
+    cfgModel.method = 'CrudProQuickAnonymous';
+    cfgModel.updateCfg = {};
+    cfgModel.sqlDatabase = this.sqlDatabase;
+    cfgModel.sqlDbType = this.sqlDbType;
+
+    if (!cfgModel.sqlTable) {
+      cfgModel.sqlTable = this.sqlTable;
+    }
+
+    if (!cfgModel.sqlTable) {
+      throw new Error('[CrudProQuick] sqlTable not found');
+    }
+
+    return await this.curdPro.executeCrudByCfg(reqJson, cfgModel);
+  }
+
+  /**
+   * 随便获取一个。不推荐使用。建议使用getUniqueOne。
+   * @deprecated
+   * @param reqJson
+   * @param sqlTable
+   * @returns 返回一条数据对象
+   */
+  public async getOne(reqJson: IRequestModel, sqlTable?: string): Promise<any> {
+    const cfgModel: IRequestCfgModel = {
+      sqlTable,
+      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY_ONE,
+    };
+    const res = await this.executeCrudByCfg(reqJson, cfgModel);
+    return res.getOneObj();
+  }
+
+  /**
+   * 期望获取唯一的一个对象，如果数据库中的数量不唯一，则报错。
+   * @param reqJson
+   * @param sqlTable
+   * @returns 返回一条数据对象
+   */
+  public async getUniqueOne(reqJson: IRequestModel, sqlTable?: string): Promise<any> {
+    const cfgModel: IRequestCfgModel = {
+      sqlTable,
+      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY_PAGE,
+    };
+    reqJson.pageNo = 1;
+    reqJson.pageSize = 1;
+    const res = await this.executeCrudByCfg(reqJson, cfgModel);
+    const resModel = res.getResModel();
+    const total_count = resModel.total_count;
+    const rows = resModel.rows;
+    if (total_count === 0) {
+      return null;
+    }
+    if (total_count > 1) {
+      throw new Error(`[CrudProQuick][getUniqueOne] only one object is required, but got ${total_count}`);
+    }
+    return rows[0];
+  }
+
+  /**
+   * 获取数据列表
+   * @param reqJson
+   * @param sqlTable 数据库表名称
+   * @returns 返回多条数据对象组成的数组
+   */
+  public async getList(reqJson: IRequestModel, sqlTable?: string): Promise<any[]> {
+    const cfgModel: IRequestCfgModel = {
+      sqlTable,
+      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
+    };
+    const res = await this.executeCrudByCfg(reqJson, cfgModel);
+    return res.getResRows();
+  }
+
+  public async getListPage(reqJson: IRequestModel, sqlTable?: string): Promise<ResModelStandard> {
+    const cfgModel: IRequestCfgModel = {
+      sqlTable,
+      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY_PAGE,
+    };
+    const res = await this.executeCrudByCfg(reqJson, cfgModel);
+    return res.getResModel(); // 因为它有2个返回值
+  }
+
+  public async getTotalCount(reqJson: IRequestModel, sqlTable?: string): Promise<number> {
+    const cfgModel: IRequestCfgModel = {
+      sqlTable,
+      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY_COUNT,
+    };
+    const res = await this.executeCrudByCfg(reqJson, cfgModel);
+    return res.getResModel().total_count;
+  }
+
+  public async insertObject(reqJson: IRequestModel, sqlTable?: string): Promise<ResModelAffected> {
+    const cfgModel: IRequestCfgModel = {
+      sqlTable,
+      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_INSERT,
+    };
+    const res = await this.executeCrudByCfg(reqJson, cfgModel);
+    return res.getResModel().affected;
+  }
+
+  public async updateObject(reqJson: IRequestModel, sqlTable?: string): Promise<ResModelAffected> {
+    const cfgModel: IRequestCfgModel = {
+      sqlTable,
+      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_UPDATE,
+    };
+    const res = await this.executeCrudByCfg(reqJson, cfgModel);
+    return res.getResModel().affected;
+  }
+
+  public async insertOrUpdate(reqJson: IRequestModel, sqlTable?: string): Promise<ResModelStandard> {
+    const cfgModel: IRequestCfgModel = {
+      sqlTable,
+      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_INSERT_OR_UPDATE,
+    };
+    const res = await this.executeCrudByCfg(reqJson, cfgModel);
+    return res.getResModel(); // 因为它有三个返回值
+  }
+
+  public async deleteObject(reqJson: IRequestModel, sqlTable?: string): Promise<ResModelAffected> {
+    const cfgModel: IRequestCfgModel = {
+      sqlTable,
+      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_DELETE,
+    };
+    const res = await this.executeCrudByCfg(reqJson, cfgModel);
+    return res.getResModel().affected;
+  }
+
+  public async executeSQL(executeSql: string, args?: any[]): Promise<any> {
+    const sqlCfgModel: ISqlCfgModel = {
+      executeSql: executeSql,
+      executeSqlArgs: args,
+      sqlDatabase: this.sqlDatabase,
+      sqlDbType: this.sqlDbType,
+      maxLimit: this.baseCfgModel.maxLimit || DEFAULT_MAX_LIMIT,
+    };
+    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

@@ -1,88 +1,161 @@
-import { Inject, Provide } from '@midwayjs/core';
-import { Context } from '@midwayjs/koa';
-import * as _ from 'lodash';
-import { CurdProService } from './CurdProService';
-import { ExecuteContext, IExecuteContextHandler } from '../../libs/crud-pro/models/ExecuteContext';
-import { CrudMixUtils, RelatedType } from './CurdMixUtils';
-import { SystemTables} from '../../models/SystemTables';
-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';
-
-const dictMixUtils = new CrudMixUtils(RelatedType.accountBasic);
-
-const TMP_CTX_KEY = _.uniqueId('CurdMixByAccountService');
-
-@Provide()
-export class CurdMixByAccountService implements IExecuteContextHandler {
-  @Inject()
-  ctx: Context;
-
-  @Inject()
-  protected curdProService: CurdProService;
-
-  async handleExecuteContextPrepare(executeContext: ExecuteContext) {
-    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
-
-
-    
-    const relations = dictMixUtils.pickColumnRelations(executeContext);
-    if (!relations || relations.length === 0) {
-      return;
-    }
-
-    const accountIds = new Set<string>();
-    dictMixUtils.forEachRowAndColumnsRelation(executeContext, (row: any, columnRelation: ColumnRelation) => {
-      const { sourceColumn } = columnRelation;
-      const accountId = _.get(row, sourceColumn);
-      if (accountId) {
-        accountIds.add(accountId);
-      }
-    });
-
-    if (accountIds.size === 0) {
-      return;
-    }
-
-    const cfgModel: IRequestCfgModel = {
-      method: 'UserAccountService.queryAccountBasicInfoByIds',
-      sqlTable: SystemTables.sys_user_account,
-      sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
-      sqlDatabase: SystemDbName,
-      sqlDdType: SystemDbType,
-    };
-
-    const reqJson: IRequestModel = {
-      columns: ['nick_name', 'avatar', 'account_id'],
-      condition: {
-        account_id: {
-          $in: [...accountIds],
-        },
-      },
-    };
-
-    const res = await this.curdProService.executeCrudByCfg(reqJson, cfgModel);
-    const userInfos = res.getResRows();
-    executeContext[TMP_CTX_KEY] = MixinUtils.toNewMap(userInfos, (obj: any) => obj.account_id);
-  }
-
-  async handleExecuteContext(executeContext: ExecuteContext): Promise<void> {
-    const userInfoMap = executeContext[TMP_CTX_KEY] as Map<string, any>;
-    if (!userInfoMap || userInfoMap.size === 0) {
-      return;
-    }
-
-    dictMixUtils.forEachRowAndColumnsRelation(executeContext, (row: any, columnRelation: ColumnRelation) => {
-      const sourceColumn = columnRelation.sourceColumn;
-      const targetColumns = columnRelation.targetColumns;
-      if (!Array.isArray(targetColumns) || targetColumns.length === 0) {
-        columnRelation.targetColumns = [
-          { from: 'nick_name', to: `${sourceColumn}_user.nick_name` },
-          { from: 'avatar', to: `${sourceColumn}_user.avatar` },
-        ];
-      }
-      dictMixUtils.copyColumnRelationToRowNoRelatedCode(row, userInfoMap, columnRelation);
-    });
-  }
-}
+import { Inject, Provide } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+import * as _ from 'lodash';
+import { CurdProService } from './CurdProService';
+import { HandleExecuteContextType, IExecuteContextHandler } from '@/libs/crud-pro/models/ExecuteContext';
+import { CrudMixUtils, RelatedType, toFatcmsUserAccountIdList } from './CurdMixUtils';
+import { SystemTables } from '@/models/SystemTables';
+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);
+
+const TMP_CTX_KEY = _.uniqueId('CurdMixByAccountService');
+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 relations = dictMixUtils.pickColumnRelations(executeContext);
+    if (!relations || relations.length === 0) {
+      return;
+    }
+
+    const isArrayModeMap = new Map<string, boolean>();
+
+    const accountIds = new Set<string>();
+    dictMixUtils.forEachRowAndColumnsRelation(executeContext, (row: any, columnRelation: ColumnRelation) => {
+      const { sourceColumn } = columnRelation;
+      if (sourceColumn) {
+        const accountId = _.get(row, sourceColumn);
+        if (accountId) {
+          const { isArray, fatcmsUserAccountIdList, fatcmsUserAccountId } = toFatcmsUserAccountIdList(accountId);
+          if(isArray) {
+            isArrayModeMap.set(sourceColumn, true);
+            fatcmsUserAccountIdList.forEach(item => accountIds.add(item));
+          } else if(fatcmsUserAccountId) {
+            accountIds.add(fatcmsUserAccountId);
+          }
+        }
+      }
+    });
+
+    if (accountIds.size === 0) {
+      return;
+    }
+
+    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(accountId: string): Promise<any> {
+    const cacheService = this.cacheServiceFactory.getCacheServiceByName(CacheNameEnum.CurdMixByAccount);
+    return cacheService.getJsonObject(accountId);
+  }
+
+  private async setToCache(accountId: string, value: any): Promise<any> {
+    const cacheService = this.cacheServiceFactory.getCacheServiceByName(CacheNameEnum.CurdMixByAccount);
+    return cacheService.setJsonObject(accountId, 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: [...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 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>;
+
+    if (!userInfoMap || userInfoMap.size === 0) {
+      return;
+    }
+
+    dictMixUtils.forEachRowAndColumnsRelation(executeContext, (row: any, columnRelation: ColumnRelation) => {
+      const sourceColumn = columnRelation.sourceColumn;
+      const targetColumns = columnRelation.targetColumns;
+      if (!Array.isArray(targetColumns) || targetColumns.length === 0) {
+        const isArrayMode = isArrayModeMap.get(sourceColumn) || false;
+        if(isArrayMode === true) {
+          columnRelation.targetColumns = [
+            { from: 'nick_name', to: `${sourceColumn}_array_info[$ARRAY_INDEX].nick_name` },
+            { from: 'avatar', to: `${sourceColumn}_array_info[$ARRAY_INDEX].avatar` },
+            { from: 'account_id', to: `${sourceColumn}_array_info[$ARRAY_INDEX].account_id` },
+          ];
+        } else {
+          columnRelation.targetColumns = [
+            { from: 'nick_name', to: `${sourceColumn}_user.nick_name` },
+            { from: 'avatar', to: `${sourceColumn}_user.avatar` },
+            { from: 'account_id', to: `${sourceColumn}_user.account_id` },
+          ];
+        }
+      }
+      dictMixUtils.copyUserInfoToRowNoRelatedCode(row, userInfoMap, columnRelation);
+    });
+  }
+}