midway-fatcms 0.0.1-beta.1

package/src/service/curd/CurdMixByDictService.ts

@@ -0,0 +1,113 @@
+import { Inject, Provide } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+import { CurdProService } from './CurdProService';
+import { ExecuteContext, IExecuteContextHandler } from '../../libs/crud-pro/models/ExecuteContext';
+import { CrudMixUtils, RelatedType } from './CurdMixUtils';
+import {SystemDbName, SystemDbType, SystemTables} from '../../models/SystemTables';
+import { KeysOfSimpleSQL } from '../../libs/crud-pro/models/keys';
+import { MultiKeyMap } from '../../libs/crud-pro/utils/MultiKeyMap';
+import { ColumnRelation } from '../../libs/crud-pro/interfaces';
+import * as _ from 'lodash';
+import {RedisCacheService} from "../base/RedisCacheService";
+
+const TMP_CTX_KEY = _.uniqueId('CurdMixByDictService');
+
+const dictMixUtils = new CrudMixUtils(RelatedType.dict);
+
+
+@Provide()
+export class CurdMixByDictService implements IExecuteContextHandler {
+  @Inject()
+  ctx: Context;
+
+  @Inject()
+  private curdProService: CurdProService;
+
+  @Inject()
+  protected redisCacheService: RedisCacheService;
+
+  private async getFromCache(code:string): Promise<any> {
+    const cacheKey = `CurdMixByDictService@@${code}`
+    return this.redisCacheService.getJsonObject(cacheKey)
+  }
+  private async setToCache(code:string, value: any): Promise<any> {
+    const cacheKey = `CurdMixByDictService@@${code}`
+    return this.redisCacheService.setJsonObject(cacheKey, value, 60 * 60 )
+  }
+
+
+  async handleExecuteContextPrepare(executeContext: ExecuteContext): Promise<void> {
+    const codes = dictMixUtils.pickColumnRelationCodes(executeContext);
+    if (!codes || codes.length === 0) {
+      return;
+    }
+    const rows = await this.getDictItemRows(codes);
+    executeContext[TMP_CTX_KEY] = new MultiKeyMap(rows, 'dict_code', 'value');
+  }
+
+  private async getDictItemRows(codes: string[]) {
+    const noCacheCodes: string[] = [];
+
+    // 从缓存里面取
+    let cachedRows = [];
+    for (let i = 0; i < codes.length; i++) {
+      const code = codes[i];
+      const rows1:any[] = await this.getFromCache(code);
+      // const rows1 = [];
+      if (rows1 && rows1.length > 0) {
+        cachedRows = cachedRows.concat(rows1);
+      } else {
+        noCacheCodes.push(code);
+      }
+    }
+
+    // 从数据库里面取
+    let selectedRows = [];
+    if (noCacheCodes.length > 0) {
+      const res1 = await this.curdProService.executeCrudByCfg(
+        {
+          condition: { dict_code: { $in: noCacheCodes } },
+        },
+        {
+          sqlTable: SystemTables.sys_data_dict_item,
+          sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
+          sqlDatabase: SystemDbName,
+          sqlDdType: SystemDbType,
+        }
+      );
+      selectedRows = res1.getResRows();
+
+      //放到缓存里
+      for (let i = 0; i < noCacheCodes.length; i++) {
+        const noCacheCode = noCacheCodes[i];
+        const rows1 = selectedRows.filter(e => e.dict_code === noCacheCode);
+        await this.setToCache(noCacheCode, rows1);
+      }
+    }
+
+    return cachedRows.concat(selectedRows);
+  }
+
+  async handleExecuteContext(executeContext: ExecuteContext): Promise<void> {
+    const multiKeyMap = executeContext[TMP_CTX_KEY] as MultiKeyMap;
+    if (!multiKeyMap || multiKeyMap.isEmpty()) {
+      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": "*",
+            "to": `${sourceColumn}_info[$ARRAY_INDEX]`
+          },
+        ];
+      }
+
+      dictMixUtils.copyColumnRelationToRow(row, multiKeyMap, columnRelation);
+    });
+  }
+}

package/src/service/curd/CurdMixByLinkToCustomService.ts

@@ -0,0 +1,167 @@
+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 {KeysOfSimpleSQL} from '../../libs/crud-pro/models/keys';
+import {ColumnRelation} from '../../libs/crud-pro/interfaces';
+import {BizException} from "../../models/devops";
+import {Exceptions} from "../../libs/crud-pro/exceptions";
+import {RedisCacheService} from "../base/RedisCacheService";
+import {parseDatabaseName} from "../../libs/crud-pro/utils/DatabaseName";
+
+const linkToCustomMixUtils = new CrudMixUtils(RelatedType.linkToCustom);
+const TMP_CTX_KEY = _.uniqueId('CurdMixByLinkToCustomService');
+
+
+@Provide()
+export class CurdMixByLinkToCustomService implements IExecuteContextHandler {
+  @Inject()
+  protected ctx: Context;
+
+  @Inject()
+  protected curdProService: CurdProService;
+
+  @Inject()
+  protected redisCacheService: RedisCacheService;
+
+
+  async handleExecuteContextPrepare(executeContext: ExecuteContext) {
+    const relations = linkToCustomMixUtils.pickColumnRelations(executeContext);
+
+    if (!relations || relations.length === 0) {
+      return;
+    }
+    executeContext[TMP_CTX_KEY] = await this.loadInfoByLinkToCustomMap(relations);
+  }
+
+  async handleExecuteContext(executeContext: ExecuteContext): Promise<void> {
+    const dataInfoMap = executeContext[TMP_CTX_KEY] as Map<string,Map<string,any>>
+    if (!dataInfoMap || dataInfoMap.size === 0) {
+      return;
+    }
+    linkToCustomMixUtils.forEachRowAndColumnsRelation(executeContext, (row: any, columnRelation: ColumnRelation) => {
+      const relatedCode = columnRelation.relatedCode;
+      const dataMap = dataInfoMap.get(relatedCode);
+      if (dataMap) {
+
+        const sourceColumn = columnRelation.sourceColumn;
+        const targetColumns = columnRelation.targetColumns;
+        if (!Array.isArray(targetColumns) || targetColumns.length === 0) {
+          columnRelation.targetColumns = [
+            {
+              "from": "*",
+              "to": `${sourceColumn}_info[$ARRAY_INDEX]`
+            },
+          ];
+        }
+
+
+        // this.ctx.logger.info("CurdMixByLinkToCustomService ==> dataMap", dataMap)
+
+        linkToCustomMixUtils.copyColumnRelationToRowNoRelatedCode(row, dataMap, columnRelation);
+      }
+    });
+  }
+
+
+  public async queryInfoByLinkToCustom(code: string): Promise<Map<string,any>> {
+    const cacheKey = "linkToCustom@@"+code;
+    let values;
+    const expireSecond = 2 * 60 ; // 2分钟
+    const enumMap = await this.redisCacheService.getJsonObject(cacheKey);
+    if (!enumMap || Object.keys(enumMap).length === 0) {
+      values = await this.queryInfoByLinkToCustomImpl(code);
+      await this.redisCacheService.setJsonObject(cacheKey, values, expireSecond);
+    }
+    return values;
+  }
+
+
+  /**
+   * code形如：mysql_________fatcms~~~sys_perm_role~~~role_code,role_name,xxx_name
+   * code形如：fatcms~~~sys_perm_role~~~role_code,role_name,xxx_name
+   * code形如：fatcms~~~sys_perm_role~~~id,*
+   * 【数据库】~~~【表名】~~~【value】,【label】，【style】
+   * @param code
+   * @private
+   */
+  private async queryInfoByLinkToCustomImpl(code: string): Promise<Map<string,any>>{
+    const arr = code
+      .split('~~~')
+      .map(s => s.trim())
+      .filter(Boolean);
+    if (arr.length !== 3) {
+      throw new BizException('linkToCustom枚举值查询字符串，必须符合固定格式', Exceptions.CFG_ERROR);
+    }
+    const [sqlDatabase, sqlTable, fields] = arr;
+
+    const {dbType, dbName} = parseDatabaseName(sqlDatabase);
+
+    const fieldsArr = fields
+      .split(',')
+      .map(s => s.trim())
+      .filter(Boolean);
+
+    if (fieldsArr.length < 2) {
+      throw new BizException('linkToCustom枚举值查询字符串，fields字段必须符合固定格式', Exceptions.CFG_ERROR);
+    }
+
+    const valueKey = fieldsArr[0];
+    const labelKey = fieldsArr[1];
+
+    const isObjectMode = fieldsArr.length > 2 || labelKey === "*";
+
+    const res1 = await this.curdProService.executeCrudByCfg(
+      {
+        condition: {},
+        columns: labelKey === "*" ? null: fields,
+        limit: 4000,
+        offset: 0,
+      },
+      {
+        sqlTable,
+        sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
+        sqlDatabase: dbName,
+        sqlDdType: dbType,
+        maxLimit: 4000,
+      }
+    );
+    const rows = res1.getResRows();
+    const map = new Map<string, any>();
+    for (let i = 0; i < rows.length; i++) {
+      const rowObj = rows[i];
+      const value =  rowObj[valueKey];
+
+      if (typeof value !== 'undefined') {
+        const valueStr = "" +value;
+        if (isObjectMode) {
+          map.set(valueStr, rowObj);
+        } else {
+          const label =  rowObj[labelKey];
+          if (label){
+            map.set(valueStr, label);
+          }
+        }
+      }
+
+
+    }
+    return map;
+  }
+
+
+  private async loadInfoByLinkToCustomMap(relations: ColumnRelation[]): Promise<Map<string,Map<string,any>>> {
+    const bigMap = new Map<string, Map<string, any>>();
+    for (let i = 0; i < relations.length; i++) {
+      const relation = relations[i];
+      const code = relation.relatedCode || "";
+      const codeTrim = code.trim();
+      const map = await this.queryInfoByLinkToCustom(codeTrim);
+      bigMap.set(codeTrim, map);
+    }
+    return bigMap;
+  }
+
+}

package/src/service/curd/CurdMixBySysConfigService.ts

@@ -0,0 +1,78 @@
+import { Inject, Provide } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+import { CurdProService } from './CurdProService';
+import { ExecuteContext, IExecuteContextHandler } from '../../libs/crud-pro/models/ExecuteContext';
+import { CrudMixUtils, RelatedType } from './CurdMixUtils';
+import * as _ from 'lodash';
+import {SystemDbName, SystemDbType, SystemTables} from '../../models/SystemTables';
+import { KeysOfSimpleSQL } from '../../libs/crud-pro/models/keys';
+import { MultiKeyMap } from '../../libs/crud-pro/utils/MultiKeyMap';
+import { ColumnRelation } from '../../libs/crud-pro/interfaces';
+import { parseConfigContentToEnumInfo } from "../../libs/utils/parseConfig";
+
+const dictMixUtils = new CrudMixUtils(RelatedType.sysCfgEnum);
+
+const TMP_CTX_KEY = _.uniqueId('CurdMixBySysConfigService');
+
+
+
+@Provide()
+export class CurdMixBySysConfigService implements IExecuteContextHandler {
+  @Inject()
+  ctx: Context;
+
+  @Inject()
+  protected curdProService: CurdProService;
+
+  async handleExecuteContextPrepare(executeContext: ExecuteContext) {
+    const codes = dictMixUtils.pickColumnRelationCodes(executeContext);
+    if (!codes || codes.length === 0) {
+      return;
+    }
+
+    const res1 = await this.curdProService.executeCrudByCfg(
+      {
+        condition: { config_code: { $in: codes } },
+      },
+      {
+        sqlTable: SystemTables.sys_configs,
+        sqlSimpleName: KeysOfSimpleSQL.SIMPLE_QUERY,
+        sqlDatabase: SystemDbName,
+        sqlDdType: SystemDbType,
+      }
+    );
+    const rows = res1.getResRows();
+    const multiKeyMap = new MultiKeyMap();
+
+    if (Array.isArray(rows)) {
+      for (let i = 0; i < rows.length; i++) {
+        const row = rows[i];
+        const { config_code } = row;
+        const config_content_rows = parseConfigContentToEnumInfo(row); // 数组元素必须有value字段
+        multiKeyMap.addRowsValue1(config_content_rows, config_code, 'value');
+      }
+    }
+
+    executeContext[TMP_CTX_KEY] = multiKeyMap;
+  }
+
+
+  async handleExecuteContext(executeContext: ExecuteContext): Promise<void> {
+    const multiKeyMap = executeContext[TMP_CTX_KEY] as MultiKeyMap;
+    if (!multiKeyMap || multiKeyMap.isEmpty()) {
+      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: 'label', to: `${sourceColumn}_info.label` },
+          { from: 'style', to: `${sourceColumn}_info.style` },
+        ];
+      }
+      dictMixUtils.copyColumnRelationToRow(row, multiKeyMap, columnRelation);
+    });
+  }
+}

package/src/service/curd/CurdMixByWorkbenchService.ts

@@ -0,0 +1,68 @@
+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 { ExecuteContext, IExecuteContextHandler } from '../../libs/crud-pro/models/ExecuteContext';
+import { CrudMixUtils, RelatedType } from './CurdMixUtils';
+import {SystemDbName, SystemDbType, 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';
+
+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() {
+    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,
+        sqlDdType: SystemDbType,
+      });
+      const workbenchList = res.getResRows();
+      workbenchListMap = MixinUtils.toNewMap(workbenchList, (obj: any) => obj.workbench_code);
+      lruCache.set('workbenchListMap', workbenchListMap);
+    }
+    return workbenchListMap;
+  }
+
+  async handleExecuteContextPrepare(executeContext: ExecuteContext) {
+    const relations = workbenchMixUtils.pickColumnRelations(executeContext);
+    if (!relations || relations.length === 0) {
+      return;
+    }
+    executeContext[TMP_CTX_KEY] = await this.loadWorkbenchListMap();
+  }
+
+  async handleExecuteContext(executeContext: ExecuteContext): 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,65 @@
+import { Inject, Provide } from '@midwayjs/core';
+import { CurdProService } from './CurdProService';
+import { CurdMixByDictService } from './CurdMixByDictService';
+import { 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";
+
+@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) {
+    this.prepare();
+    return this.curdProService.executeCrudByCfg(reqJson, cfgModel);
+  }
+
+  getBbUtil(database: string, sqlDdType: SqlDbType) {
+    this.prepare();
+    return this.curdProService.getBbUtil(database, sqlDdType);
+  }
+
+  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);
+  }
+}