midway-fatcms 0.0.1-beta.55 → 0.0.1-beta.56

package/src/service/curd/CurdMixByWorkbenchService.ts

@@ -0,0 +1,71 @@
+import { Inject, Provide } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+import * as _ from 'lodash';
+import { LRUCache } from 'lru-cache';
+import { CurdProService } from './CurdProService';
+import { HandleExecuteContextType, 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 } from '@/libs/crud-pro/interfaces';
+import { MixinUtils } from '@/libs/crud-pro/utils/MixinUtils';
+import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
+
+const lruCache = new LRUCache<string, any>({
+  max: 500,
+  ttl: 1000 * 60 * 5,
+  ttlAutopurge: true,
+});
+
+const workbenchMixUtils = new CrudMixUtils(RelatedType.workbenchBasic);
+
+const TMP_CTX_KEY = _.uniqueId('CurdMixByWorkbenchService');
+
+@Provide()
+export class CurdMixByWorkbenchService implements IExecuteContextHandler {
+  @Inject()
+  ctx: Context;
+
+  @Inject()
+  protected curdProService: CurdProService;
+
+  private async loadWorkbenchListMap() {
+    const { SystemDbName, SystemDbType } = 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.sys_workbench,
+        sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
+        sqlDatabase: SystemDbName,
+        sqlDbType: SystemDbType,
+      });
+      const workbenchList = res.getResRows();
+      workbenchListMap = MixinUtils.toNewMap(workbenchList, (obj: any) => obj.workbench_code);
+      lruCache.set('workbenchListMap', workbenchListMap);
+    }
+    return workbenchListMap;
+  }
+
+  async handleExecuteContextPrepare(executeContext: HandleExecuteContextType) {
+    const relations = workbenchMixUtils.pickColumnRelations(executeContext);
+    if (!relations || relations.length === 0) {
+      return;
+    }
+    executeContext[TMP_CTX_KEY] = await this.loadWorkbenchListMap();
+  }
+
+  async handleExecuteContext(executeContext: HandleExecuteContextType): Promise<void> {
+    const userInfoMap = executeContext[TMP_CTX_KEY] as Map<string, any>;
+    if (!userInfoMap || userInfoMap.size === 0) {
+      return;
+    }
+    workbenchMixUtils.forEachRowAndColumnsRelation(executeContext, (row: any, columnRelation: ColumnRelation) => {
+      workbenchMixUtils.copyColumnRelationToRowNoRelatedCode(row, userInfoMap, columnRelation);
+    });
+  }
+}

package/src/service/curd/CurdMixService.ts

@@ -0,0 +1,97 @@
+import { Inject, Provide } from '@midwayjs/core';
+import { CurdProService } from './CurdProService';
+import { CurdMixByDictService } from './CurdMixByDictService';
+import { ColumnRelation, IRequestCfgModel, IRequestModel, ISqlCfgModel } from '@/libs/crud-pro/interfaces';
+import { CurdMixBySysConfigService } from './CurdMixBySysConfigService';
+import { CurdMixByAccountService } from './CurdMixByAccountService';
+import { RelatedType } from './CurdMixUtils';
+import { CurdMixByWorkbenchService } from './CurdMixByWorkbenchService';
+import { IRequestCfgModel2 } from '@/models/bizmodels';
+import { CurdMixByLinkToCustomService } from './CurdMixByLinkToCustomService';
+import { SqlDbType } from '@/libs/crud-pro/models/keys';
+import { ExecuteContext, IExecuteContextCustom } from '@/libs/crud-pro/models/ExecuteContext';
+
+export interface ILinkColumnRelationParam {
+  columnsRelations: ColumnRelation[];
+}
+
+@Provide()
+export class CurdMixService {
+  @Inject()
+  private curdProService: CurdProService;
+
+  @Inject()
+  private curdMixByDictService: CurdMixByDictService;
+
+  @Inject()
+  private curdMixBySysConfigService: CurdMixBySysConfigService;
+
+  @Inject()
+  private curdMixByAccountService: CurdMixByAccountService;
+
+  @Inject()
+  private curdMixByWorkbenchService: CurdMixByWorkbenchService;
+
+  @Inject()
+  private curdMixByLinkToCustomService: CurdMixByLinkToCustomService;
+
+  private prepare() {
+    this.curdProService.setResponseCfgHandlers(RelatedType.dict, this.curdMixByDictService);
+    this.curdProService.setResponseCfgHandlers(RelatedType.sysCfgEnum, this.curdMixBySysConfigService);
+    this.curdProService.setResponseCfgHandlers(RelatedType.accountBasic, this.curdMixByAccountService);
+    this.curdProService.setResponseCfgHandlers(RelatedType.workbenchBasic, this.curdMixByWorkbenchService);
+    this.curdProService.setResponseCfgHandlers(RelatedType.linkToCustom, this.curdMixByLinkToCustomService);
+  }
+
+  async executeCrudByCfg(reqJson: IRequestModel, cfgModel: IRequestCfgModel2): Promise<ExecuteContext> {
+    this.prepare();
+    return this.curdProService.executeCrudByCfg(reqJson, cfgModel);
+  }
+
+  getBbUtil(sqlDatabase: string, sqlDbType: SqlDbType, sqlTable?: string) {
+    this.prepare();
+    return this.curdProService.getBbUtil(sqlDatabase, sqlDbType, sqlTable);
+  }
+
+  async executeSQL(sqlCfgModel: ISqlCfgModel) {
+    this.prepare();
+    return this.curdProService.executeSQL(sqlCfgModel);
+  }
+
+  async executeCrud(reqJson: IRequestModel) {
+    this.prepare();
+    return this.curdProService.executeCrud(reqJson);
+  }
+
+  public async getCachedCfgByMethod(method: string): Promise<IRequestCfgModel> {
+    return this.curdProService.getCachedCfgByMethod(method);
+  }
+
+  /**
+   * 根据配置的关联关系，直接关联数据
+   * @param rows
+   * @param param
+   * @returns
+   */
+  public async linkColumnRelationDatas(rows: any[], param: ILinkColumnRelationParam) {
+    if (!Array.isArray(rows) || rows.length === 0) {
+      return;
+    }
+
+    this.prepare();
+
+    const exeCtx: IExecuteContextCustom = {
+      rows,
+      columnsRelation: param.columnsRelations,
+      isCustomContext: true,
+    };
+
+    const responseCfgHandlers = this.curdProService.getResponseCfgHandlers();
+    const handlers = Object.values(responseCfgHandlers);
+    for (let i = 0; i < handlers.length; i++) {
+      const handler = handlers[i];
+      await handler.handleExecuteContextPrepare(exeCtx);
+      await handler.handleExecuteContext(exeCtx);
+    }
+  }
+}

package/src/service/curd/CurdMixUtils.ts

@@ -0,0 +1,316 @@
+import { ColumnRelation, CopyAttr } from '@/libs/crud-pro/interfaces';
+import { ExecuteContext, HandleExecuteContextType, IExecuteContextCustom } from '@/libs/crud-pro/models/ExecuteContext';
+import { KeyOfCrudTypes } from '@/libs/crud-pro/models/keys';
+import { MixinUtils } from '@/libs/crud-pro/utils/MixinUtils';
+import { SqlCfgModel } from '@/libs/crud-pro/models/SqlCfgModel';
+import { RequestCfgModel } from '@/libs/crud-pro/models/RequestCfgModel';
+import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
+import * as _ from 'lodash';
+import { MultiKeyMap } from '@/libs/crud-pro/utils/MultiKeyMap';
+import { parseJsonObject } from '@/libs/utils/functions';
+
+enum RelatedType {
+  dict = 'dict', // 关联数据字典
+  sysCfgEnum = 'sysCfgEnum', // 配置文件中，必须包含code一列，作为唯一键。
+  linkToCustom = 'linkToCustom', // 自定义指定任何表
+  accountBasic = 'accountBasic', // 个人账号基本信息
+  workbenchBasic = 'workbenchBasic', // 站点基本信息
+}
+
+type FuncRowColumnRelation = (row: any, columnRelation: ColumnRelation) => void;
+
+const { isNotEmpty } = MixinUtils;
+
+function getColumnsRelationAll(sqlCfg: SqlCfgModel, cfgModel: RequestCfgModel): ColumnRelation[] {
+  if (sqlCfg && Array.isArray(sqlCfg.columnsRelation) && sqlCfg.columnsRelation.length > 0) {
+    return sqlCfg.columnsRelation;
+  }
+  if (cfgModel && Array.isArray(cfgModel.columnsRelation) && cfgModel.columnsRelation.length > 0) {
+    return cfgModel.columnsRelation;
+  }
+  return [];
+}
+
+const forEachColumnsRelation = (row: any, columnsRelation: ColumnRelation[], func: FuncRowColumnRelation) => {
+  for (let i = 0; i < columnsRelation.length; i++) {
+    func(row, columnsRelation[i]);
+  }
+};
+
+function copyBySingleSourceValue(row: any, sourceValue: any, targetColumns: CopyAttr[], getValue: any) {
+  // const codeObject = map.get(sourceValue);
+  const codeObject = getValue(sourceValue);
+  if (typeof codeObject === 'undefined' || codeObject === null) {
+    return;
+  }
+
+  if (Array.isArray(targetColumns)) {
+    for (let i = 0; i < targetColumns.length; i++) {
+      const targetColumn = targetColumns[i];
+      const toStr = targetColumn.to.replace('[$ARRAY_INDEX]', '');
+      if (targetColumn.from === '*') {
+        _.set(row, toStr, codeObject);
+      } else {
+        const dictAttrValue = _.get(codeObject, targetColumn.from);
+        if (typeof dictAttrValue !== 'undefined' && dictAttrValue !== null) {
+          _.set(row, toStr, dictAttrValue);
+        }
+      }
+    }
+  }
+}
+
+function copyByArraySourceValueInner(row: any, codes: any[], targetColumns: CopyAttr[], getValue: any, resultObj: any) {
+  for (let codeIndex = 0; codeIndex < codes.length; codeIndex++) {
+    const code = codes[codeIndex];
+    // const codeObject = map.get(code);
+    const codeObject = getValue(code);
+    if (codeObject) {
+      if (Array.isArray(targetColumns)) {
+        for (let i = 0; i < targetColumns.length; i++) {
+          const targetColumn = targetColumns[i];
+
+          if (targetColumn.from === '*') {
+            const toStr = targetColumn.to.replace('$ARRAY_INDEX', `${codeIndex}`);
+            _.set(row, toStr, codeObject);
+
+            resultObj.isSetArray = true;
+          } else {
+            const dictAttrValue = _.get(codeObject, targetColumn.from);
+            if (typeof dictAttrValue !== 'undefined' && dictAttrValue !== null) {
+              const toStr = targetColumn.to.replace('$ARRAY_INDEX', `${codeIndex}`);
+              _.set(row, toStr, dictAttrValue);
+              resultObj.isSetArray = true;
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+function copyByArraySourceValue(row: any, sourceValue: any, targetColumns: CopyAttr[], getValue: any): boolean {
+  const resultObj = { isSetArray: false };
+  // 支持关联JSON数组。使用 字符串存储的类型
+  if (typeof sourceValue === 'string' && sourceValue.startsWith('[') && sourceValue.endsWith(']')) {
+    const codes = parseJsonObject(sourceValue);
+    if (Array.isArray(codes)) {
+      copyByArraySourceValueInner(row, codes, targetColumns, getValue, resultObj);
+    }
+  } else if (Array.isArray(sourceValue)) {
+    // 直接使用JSON或者postgres的数组存储的类型
+    copyByArraySourceValueInner(row, sourceValue, targetColumns, getValue, resultObj);
+  }
+  return resultObj.isSetArray;
+}
+
+class CrudMixUtils {
+  private readonly relatedType: RelatedType;
+  constructor(relatedType: RelatedType) {
+    this.relatedType = relatedType;
+  }
+
+  private getColumnsRelation(sqlCfg: SqlCfgModel, cfgModel: RequestCfgModel): ColumnRelation[] {
+    const ss = getColumnsRelationAll(sqlCfg, cfgModel);
+    const relatedType = this.relatedType;
+    return ss.filter(s => s.relatedType === relatedType);
+  }
+
+  /**
+   * 从执行上下文，获取所有的关联关系
+   * @param exeCtxType
+   * @returns
+   */
+  public pickColumnRelations(exeCtxType: HandleExecuteContextType): ColumnRelation[] {
+    // 自定义的关联关系
+    const customExeCtx = exeCtxType as IExecuteContextCustom;
+    if (customExeCtx.isCustomContext) {
+      const customExeCtx = exeCtxType as IExecuteContextCustom;
+      return customExeCtx.columnsRelation;
+    }
+
+    // 默认的执行上下文
+    const relationResult: ColumnRelation[] = [];
+    const exeCtx: ExecuteContext = exeCtxType as ExecuteContext;
+    const cfgModel = exeCtx.getCfgModel();
+    const sqlModels = exeCtx.getSqlCfgModels();
+    if (Array.isArray(sqlModels) && sqlModels.length > 0) {
+      for (let i = 0; i < sqlModels.length; i++) {
+        const sqlModel = sqlModels[i];
+        // 只有Select语句需要
+        if (sqlModel && sqlModel.getCrudType() === KeyOfCrudTypes.SELECT) {
+          const columnsRelation = this.getColumnsRelation(sqlModel, cfgModel);
+          for (let j = 0; j < columnsRelation.length; j++) {
+            const relation = columnsRelation[j];
+            if (relation.relatedType === this.relatedType) {
+              relationResult.push(relation);
+            }
+          }
+        }
+      }
+    }
+
+    return _.uniqBy(relationResult, (obj: ColumnRelation) => {
+      return `${obj.relatedCode}_${obj.relatedType}_${obj.sourceColumn}_${JSON.stringify(obj.targetColumns)}`;
+    });
+  }
+
+  /**
+   * 从执行上下文，获取所有的关联关系的代码
+   * @param exeCtx
+   * @returns
+   */
+  public pickColumnRelationCodes(exeCtx: HandleExecuteContextType): string[] {
+    const relationResult: ColumnRelation[] = this.pickColumnRelations(exeCtx);
+    const codes = relationResult.map(e => e.relatedCode);
+    if (!codes || codes.length === 0) {
+      return [];
+    }
+    return [...new Set(codes)]; // 去重
+  }
+
+  /**
+   * 遍历每一行，每一个关联列
+   * @param exeCtxType
+   * @param func
+   * @returns
+   */
+  public forEachRowAndColumnsRelation(exeCtxType: HandleExecuteContextType, func: FuncRowColumnRelation) {
+    // 自定义的关联关系
+    const customExeCtx = exeCtxType as IExecuteContextCustom;
+    if (customExeCtx.isCustomContext) {
+      const rows = customExeCtx.rows || [];
+      const columnsRelation = customExeCtx.columnsRelation;
+      for (let index = 0; index < rows.length; index++) {
+        const row = rows[index];
+        forEachColumnsRelation(row, columnsRelation, func);
+      }
+
+      return;
+    }
+
+    // 默认的执行上下文
+    const exeCtx: ExecuteContext = exeCtxType as ExecuteContext;
+    const sqlCfgList = exeCtx.getSqlCfgModels();
+    const resModel = exeCtx.getResModel();
+    const cfgModel = exeCtx.getCfgModel();
+
+    for (let i = 0; i < sqlCfgList.length; i++) {
+      const sqlCfg = sqlCfgList[i];
+
+      // 只有Select语句需要
+      if (sqlCfg && sqlCfg.getCrudType() === KeyOfCrudTypes.SELECT) {
+        const columnsRelation = this.getColumnsRelation(sqlCfg, cfgModel);
+
+        if (isNotEmpty(columnsRelation)) {
+          const resValue = resModel[sqlCfg.resName];
+          if (Array.isArray(resValue) && isNotEmpty(resValue)) {
+            // 多行查询时
+            for (const row of resValue) {
+              forEachColumnsRelation(row, columnsRelation, func);
+            }
+          } else if (typeof resValue === 'object' && isNotEmpty(resValue)) {
+            // 单行查询时
+            forEachColumnsRelation(resValue, columnsRelation, func);
+          }
+        }
+      }
+    }
+  }
+
+  public copyColumnRelationToRow(row: any, multiKeyMap: MultiKeyMap, columnRelation: ColumnRelation) {
+    const { relatedCode, sourceColumn, targetColumns } = columnRelation;
+
+    if (!sourceColumn || !targetColumns) {
+      return;
+    }
+
+    const sourceValue = _.get(row, sourceColumn);
+    if (typeof sourceValue === 'undefined' || sourceValue === null) {
+      return;
+    }
+
+    const getValue = (code: string) => {
+      return multiKeyMap.getValue(relatedCode, code);
+    };
+
+    const isSetArray = copyByArraySourceValue(row, sourceValue, targetColumns, getValue);
+    if (!isSetArray) {
+      copyBySingleSourceValue(row, sourceValue, targetColumns, getValue);
+    }
+  }
+
+  /**
+   * 无relatedCode模式
+   * @param row
+   * @param map
+   * @param columnRelation
+   */
+  public copyColumnRelationToRowNoRelatedCode(row: any, map: Map<string, any>, columnRelation: ColumnRelation) {
+    const { sourceColumn, targetColumns } = columnRelation;
+    if (!sourceColumn || !targetColumns) {
+      return;
+    }
+
+    const sourceValue = _.get(row, sourceColumn);
+    if (!sourceValue) {
+      return;
+    }
+
+    const getValue = (code: string) => {
+      if (!map) {
+        return null;
+      }
+      if (typeof map.get === 'function') {
+        return map.get(`${code}`);
+      }
+      return map[code];
+    };
+
+    const isSetArray = copyByArraySourceValue(row, sourceValue, targetColumns, getValue);
+    if (!isSetArray) {
+      copyBySingleSourceValue(row, sourceValue, targetColumns, getValue);
+    }
+  }
+
+  /**
+   * 专门COPY用户信息到row上面。无relatedCode模式
+   * @param row
+   * @param map
+   * @param columnRelation
+   */
+  public copyUserInfoToRowNoRelatedCode(row: any, map: Map<string, any>, columnRelation: ColumnRelation) {
+    const { targetColumns, sourceColumn } = columnRelation;
+
+    if (!targetColumns) {
+      return;
+    }
+
+
+    const accountId = _.get(row, sourceColumn);
+    if (!accountId) {
+      return;
+    }
+
+    const { toFatcmsUserAccountId } = GLOBAL_STATIC_CONFIG.getConfig();
+    const fatcmsUserAccountId = toFatcmsUserAccountId(accountId);
+
+
+    const getValue = (code: string) => {
+      if (!map) {
+        return null;
+      }
+      if (typeof map.get === 'function') {
+        return map.get(`${code}`);
+      }
+      return map[code];
+    };
+
+    const isSetArray = copyByArraySourceValue(row, fatcmsUserAccountId, targetColumns, getValue);
+    if (!isSetArray) {
+      copyBySingleSourceValue(row, fatcmsUserAccountId, targetColumns, getValue);
+    }
+  }
+}
+
+export { CrudMixUtils, RelatedType, FuncRowColumnRelation };