midway-fatcms 0.0.1-beta.1

package/src/libs/crud-pro/services/CrudProExecuteFuncService.ts

@@ -0,0 +1,128 @@
+import { CrudProServiceBase } from './CrudProServiceBase';
+import { IFuncCfgModel, IFunctionParam } from '../interfaces';
+import { FuncContext } from '../models/FuncContext';
+import { TypeUtils } from '../utils/TypeUtils';
+import { MixinUtils } from '../utils/MixinUtils';
+import * as _ from 'lodash';
+import { CommonException, Exceptions } from '../exceptions';
+import { KeysOfFunCtx } from '../models/keys';
+
+const { isNil, isNumeric } = TypeUtils;
+const { isEmpty } = MixinUtils;
+
+function isNotNil(obj: any): boolean {
+  return !isNil(obj);
+}
+
+class CrudProExecuteFuncService extends CrudProServiceBase {
+  executeFuncCfg(funCfg: IFuncCfgModel, funcContext: FuncContext) {
+    if (isNil(funCfg)) {
+      return null;
+    }
+
+    if (funCfg.___PLAIN_OBJECT___ === true) {
+      return funCfg;
+    }
+
+    if (isNotNil(funCfg.const)) {
+      return funCfg.const;
+    }
+    if (isNotNil(funCfg.constString)) {
+      return '' + funCfg.constString;
+    }
+    if (isNotNil(funCfg.constNumber) && isNumeric(funCfg.constNumber)) {
+      return Number(funCfg.constNumber);
+    }
+    if (isNotNil(funCfg.constBool)) {
+      return Boolean(funCfg.constBool);
+    }
+
+    if (isNotNil(funCfg.context)) {
+      return this.pickContextValue(funCfg.context, funcContext);
+    }
+    if (isNotNil(funCfg.contextAsString)) {
+      return '' + this.pickContextValue(funCfg.contextAsString, funcContext);
+    }
+    if (isNotNil(funCfg.contextAsNumber)) {
+      return Number(this.pickContextValue(funCfg.contextAsNumber, funcContext));
+    }
+    if (isNotNil(funCfg.contextAsBool)) {
+      return Boolean(this.pickContextValue(funCfg.contextAsBool, funcContext));
+    }
+
+    if (isNotNil(funCfg.functionName)) {
+      const func = this.getExecuteFunction(funCfg.functionName);
+      if (!func) {
+        throw new CommonException(Exceptions.RUN_FUNCTION_NOT_FOUND, funCfg.functionName);
+      }
+      const functionParamValues = this.getFunctionParamValues(funCfg.functionParams, funcContext);
+      return func.apply(funcContext, functionParamValues);
+    }
+    return null;
+  }
+
+  private pickContextValue(pickString: string, funcCtx: FuncContext) {
+    if (!pickString) {
+      return null;
+    }
+
+    if (pickString === KeysOfFunCtx.FUNC_CTX) {
+      return funcCtx;
+    }
+
+    if (pickString === KeysOfFunCtx.CURRENT_VALUE) {
+      return funcCtx.currentValue;
+    }
+
+    // 例如：accountId, 访问此变量，用户必须登录。
+    if (pickString.startsWith(KeysOfFunCtx.VISITOR_ATTR)) {
+      const reqModel = funcCtx?.reqModel;
+      const attrValue = _.get(reqModel, pickString); // visitor.nickName
+      if (isNil(attrValue)) {
+        throw new CommonException(Exceptions.RUN_PICK_ERR_VISITOR_NULL, '获取用户ID失败, 可能用户没有登陆');
+      }
+      return attrValue;
+    }
+
+    // 例如：accountId, 访问此变量，用户必须登录。
+    if (pickString === KeysOfFunCtx.VISITOR) {
+      const visitor = funcCtx?.reqModel?.visitor;
+      if (isNil(visitor)) {
+        throw new CommonException(Exceptions.RUN_PICK_ERR_VISITOR_NULL, '获取用户对象失败, 可能用户没有登陆');
+      }
+      return visitor;
+    }
+
+    // 例如： req.data.name
+    if (pickString.startsWith(KeysOfFunCtx.REQUEST)) {
+      const reqExpress = pickString.substring(KeysOfFunCtx.REQUEST.length);
+      return _.get(funcCtx.reqModel, reqExpress);
+    }
+
+    // 例如： res.total_count
+    if (pickString.startsWith(KeysOfFunCtx.RESULT)) {
+      const reqExpress = pickString.substring(KeysOfFunCtx.RESULT.length);
+      return _.get(funcCtx.resModel, reqExpress);
+    }
+
+    return null;
+  }
+
+  private getFunctionParamValues(functionParams: IFunctionParam[], funcContext: FuncContext): any[] {
+    if (isNil(functionParams) || isEmpty(functionParams)) {
+      return [];
+    }
+    return functionParams.map(p => {
+      if (typeof p === 'undefined' || p === null) {
+        return null;
+      }
+
+      if (typeof p === 'string' || typeof p === 'number' || typeof p === 'boolean') {
+        return p;
+      }
+      return this.executeFuncCfg(p, funcContext);
+    });
+  }
+}
+
+export { CrudProExecuteFuncService };

package/src/libs/crud-pro/services/CrudProExecuteSqlService.ts

@@ -0,0 +1,279 @@
+import * as _ from 'lodash';
+import {PoolClient} from 'pg'
+import {CrudProServiceBase} from './CrudProServiceBase';
+import {SqlCfgModel} from '../models/SqlCfgModel';
+import {KeyOfCrudTypes, KeysOfCustomSQL, KeysOfSqlResPicker, SqlDbType} from '../models/keys';
+import {CommonException, Exceptions} from '../exceptions';
+import {pickAndConvertPgRows} from '../utils/sqlConvert/convertPgType';
+import {replaceQuestionMarks} from "../utils/sqlConvert/convertPgSql";
+import {replaceQuestionMarksForMssql} from "../utils/sqlConvert/convertMsSql";
+import {ModelUtils} from '../utils/ModelUtils';
+import {MixinUtils} from '../utils/MixinUtils';
+import {FuncContext} from '../models/FuncContext';
+import {ExecuteContext} from "../models/ExecuteContext";
+
+const { checkFuncCfgValid } = ModelUtils;
+const { isEmpty } = MixinUtils;
+
+class CrudProExecuteSqlService extends CrudProServiceBase {
+  async executeSqlCfgModels(): Promise<void> {
+    const exeCtx = this.getExecuteContext();
+    const sqlCfgModels = exeCtx.getSqlCfgModels();
+    for (let i = 0; i < sqlCfgModels.length; i++) {
+      const sqlCfgModel = sqlCfgModels[i];
+      const checkResult = this.executeSqlCfgModelPreCheck(sqlCfgModel);
+      if (checkResult) {
+        await this.executeSqlCfgModel(sqlCfgModel);
+      }
+    }
+  }
+
+  private async executeSqlCfgModel(sqlCfgModel: SqlCfgModel) {
+    this.logger.info('executeSqlCfgModel1', sqlCfgModel.executeSql, sqlCfgModel.executeSqlArgs);
+
+    const exeCtx = this.getExecuteContext();
+    const connection = await this.getTxConnectionBySqlCfg(sqlCfgModel);
+    const executeSqlArgs = this.handleExecuteSqlArgsByResModel(exeCtx, sqlCfgModel.executeSqlArgs || [])
+
+
+    let sqlRes: any;
+    let queryRes : any;
+
+    if (sqlCfgModel.sqlDdType === SqlDbType.postgres) { // import { PoolClient } from 'pg';
+
+      const pgClient: PoolClient = connection as any;
+      const pgSql = replaceQuestionMarks(sqlCfgModel.executeSql);
+
+      this.logger.info('executeSqlCfgModel_postgres', pgSql, executeSqlArgs, sqlCfgModel.resPicker);
+
+
+      queryRes = await pgClient.query({
+        text: pgSql,
+        values: executeSqlArgs || []
+      });
+      sqlRes = pickAndConvertPgRows(queryRes)
+
+    }
+
+    else if (sqlCfgModel.sqlDdType === SqlDbType.sqlserver) {
+
+      const mssql = replaceQuestionMarksForMssql(sqlCfgModel.executeSql);
+
+      this.logger.info('executeSqlCfgModel_sqlserver', mssql, executeSqlArgs, sqlCfgModel.resPicker);
+      // SQLServer
+      queryRes = await connection.query(mssql, executeSqlArgs);
+      sqlRes = _.get(queryRes,'recordsets[0]') || []
+    }
+
+    else {
+
+      this.logger.info('executeSqlCfgModel_mysql', sqlCfgModel.executeSql, executeSqlArgs, sqlCfgModel.resPicker);
+
+
+      // MYSQL
+      queryRes = await connection.query(sqlCfgModel.executeSql, executeSqlArgs);
+      sqlRes = queryRes[0]
+    }
+
+    const resObject = this.toQueryResByResPicker(sqlRes, queryRes, sqlCfgModel);
+    exeCtx.setResModelItem(sqlCfgModel.resName, resObject);
+  }
+
+
+  private handleExecuteSqlArgsByResModel(exeCtx: ExecuteContext, executeSqlArgs: any[]): any[] {
+    return executeSqlArgs.map((arg)=> {
+      if (arg && typeof arg === 'object' && typeof arg.___GENERATE_GET_RES_ATTR___ === 'string' ) {
+        const word: string = arg.___GENERATE_GET_RES_ATTR___;
+        if (word.startsWith(KeysOfCustomSQL.SQL_PICK_RES_AS_NUMBER)) {
+          const resName = MixinUtils.removeStringPrefix(word, KeysOfCustomSQL.SQL_PICK_RES_AS_NUMBER)
+          this.logger.info('handleExecuteSqlArgsByResModel resName', resName);
+          this.logger.info('handleExecuteSqlArgsByResModel getResModel', exeCtx.getResModel());
+          return Number(exeCtx.getResModelItemLodash(resName) || 0);
+        }
+        if (word.startsWith(KeysOfCustomSQL.SQL_PICK_RES_AS_STRING)) {
+          const resName = MixinUtils.removeStringPrefix(word, KeysOfCustomSQL.SQL_PICK_RES_AS_STRING)
+          return String(exeCtx.getResModelItemLodash(resName) || "");
+        }
+      }
+      return arg;
+    })
+  }
+
+
+  private executeSqlCfgModelPreCheck(sqlCfgModel: SqlCfgModel): boolean {
+    const crudType = sqlCfgModel.getCrudType();
+
+    if (KeyOfCrudTypes.EMPTY_SQL === crudType) {
+      // 允许空SQL，没有需要执行的正常。
+      return false;
+    }
+
+    if (KeyOfCrudTypes.NOT_CRUD === crudType) {
+      // 只支持增删改查，其他语句不支持。
+      throw new CommonException(Exceptions.CFG_NOT_SUPPORT_THE_SQL, sqlCfgModel.executeSql);
+    }
+
+    // 此SQL不需要执行
+    if (!this.isNeedExecute(sqlCfgModel)) {
+      return false;
+    }
+
+    // 执行之前，根据配置校验一下此SQL是否可以执行
+    this.assertByValidate(sqlCfgModel);
+
+    return true;
+  }
+
+  private assertByValidate(sqlCfgModel: SqlCfgModel) {
+    const exeCtx = this.getExecuteContext();
+    const funcCfg = sqlCfgModel.validate;
+    if (!funcCfg) {
+      return; // 没有配置。
+    }
+
+    if (!checkFuncCfgValid(funcCfg)) {
+      throw new CommonException(Exceptions.CFG_SQL_CFG_EXECUTE_VALIDATE_EMPTY, {
+        funcCfg: funcCfg,
+        originSql: sqlCfgModel.originSql,
+      });
+    }
+
+    const errMsg = funcCfg.message || '执行前校验失败';
+
+    let result;
+    try {
+      const exeFunCtx = new FuncContext();
+
+      exeFunCtx.currentValue = null;
+      exeFunCtx.reqModel = exeCtx.getReqModel();
+      exeFunCtx.resModel = exeCtx.getResModel();
+
+      result = this.serviceHub.executeFuncCfg(funcCfg, exeFunCtx); // 可以抛出异常
+    } catch (e) {
+      this.logger.debug('assertByValidate', e);
+      throw new CommonException(Exceptions.RUN_EXECUTE_VALIDATE, {
+        funcCfg: funcCfg,
+        originSql: sqlCfgModel.originSql,
+        error: '' + e,
+      });
+    }
+
+    if (!(typeof result === 'boolean')) {
+      // 自定义的校验函数，必须返回boolean类型的树枝
+      throw new CommonException(Exceptions.CFG_IS_NEED_EXECUTE_FUNC_MUST_RETURN_BOOL, {
+        funcCfg: funcCfg,
+        originSql: sqlCfgModel.originSql,
+      });
+    }
+
+    if (result === false) {
+      throw new CommonException(Exceptions.RUN_EXECUTE_VALIDATE, errMsg);
+    }
+  }
+
+  /**
+   * 判断此SQL是否需要执行
+   * @param sqlCfgModel
+   * @param exeCtx
+   * @private
+   */
+  private isNeedExecute(sqlCfgModel: SqlCfgModel) {
+    const exeCtx = this.getExecuteContext();
+    const funcCfg = sqlCfgModel.executeWhen;
+    if (!funcCfg || Object.keys(funcCfg).length === 0) {
+      return true; // 没有配置。默认，需要执行。
+    }
+
+    if (!checkFuncCfgValid(funcCfg)) {
+      throw new CommonException(Exceptions.CFG_CHECK_EXECUTE_WHEN_EMPTY, {
+        funcCfg: funcCfg,
+        originSql: sqlCfgModel.originSql,
+      });
+    }
+
+    let result;
+
+    try {
+      const exeFunCtx = new FuncContext();
+
+      exeFunCtx.currentValue = null;
+      exeFunCtx.reqModel = exeCtx.getReqModel();
+      exeFunCtx.resModel = exeCtx.getResModel();
+
+      result = this.serviceHub.executeFuncCfg(funcCfg, exeFunCtx);
+    } catch (e) {
+      this.logger.debug('isNeedExecute', e);
+      throw new CommonException(Exceptions.RUN_IS_NEED_EXECUTE_ERR, {
+        funcCfg: funcCfg,
+        originSql: sqlCfgModel.originSql,
+        error: '' + e,
+      });
+    }
+
+    if (!(typeof result === 'boolean')) {
+      // 自定义的校验函数，必须返回boolean类型的树枝
+      throw new CommonException(Exceptions.CFG_IS_NEED_EXECUTE_FUNC_MUST_RETURN_BOOL, {
+        funcCfg: funcCfg,
+        originSql: sqlCfgModel.originSql,
+      });
+    }
+
+    return result === true;
+  }
+
+  private toQueryResByResPicker(sqlRes: any, queryRes: any, sqlCfgModel: SqlCfgModel) {
+    const resPicker = sqlCfgModel.resPicker;
+
+    // 返回第一行
+    if (KeysOfSqlResPicker.RESULT_FIRST_ROW === resPicker) {
+      const rows = sqlRes as any[];
+      if (rows && rows.length > 0) {
+        return rows[0];
+      }
+      return null;
+    }
+
+    // $ResultSet[0].total_count ， 只取第一行的的total_count
+    if (KeysOfSqlResPicker.RESULT_TOTAL_COUNT === resPicker) {
+      const rows = sqlRes as any[];
+      if (isEmpty(rows)) {
+        return 0;
+      }
+      const map0 = rows[0];
+      return Number(map0['total_count'] || 0);
+    }
+
+    // 增删改res的内容是修改结果：包括： insert\delete\update
+    if (KeysOfSqlResPicker.UPDATE_RESULT === resPicker) {
+      if (sqlCfgModel.sqlDdType === SqlDbType.postgres) {
+        return {
+          insertId: _.get(queryRes,'rows[0].id'),
+          affectedRows: _.get(queryRes,'rowCount')
+        }
+      }
+
+      if (sqlCfgModel.sqlDdType === SqlDbType.sqlserver) {
+        return {
+          insertId: _.get(queryRes,'recordset[0].id'),
+          affectedRows: _.get(queryRes,'rowsAffected[0]')
+        }
+      }
+
+      return sqlRes;
+    }
+
+    //其他配置：形如： sqlRes[0].total_count
+    if (typeof resPicker === 'string') {
+      if (resPicker.startsWith('sqlRes')){
+        return _.get({ sqlRes }, resPicker);
+      } else {
+        throw  new CommonException(Exceptions.RUN_EXECUTE_VALIDATE, 'resPicker必须是以sqlRes开头')
+      }
+    }
+
+    return sqlRes;
+  }
+
+}
+
+export { CrudProExecuteSqlService };

package/src/libs/crud-pro/services/CrudProFieldUpdateService.ts

@@ -0,0 +1,60 @@
+import { RequestModel } from '../models/RequestModel';
+import { CrudProServiceBase } from './CrudProServiceBase';
+import { RequestCfgModel } from '../models/RequestCfgModel';
+import { MixinUtils } from '../utils/MixinUtils';
+import { IFuncCfgModel } from '../interfaces';
+import * as _ from 'lodash';
+import { ModelUtils } from '../utils/ModelUtils';
+import { CommonException, Exceptions } from '../exceptions';
+import { FuncContext } from '../models/FuncContext';
+const { checkFuncCfgValid } = ModelUtils;
+const { isEmpty } = MixinUtils;
+
+class CrudProFieldUpdateService extends CrudProServiceBase {
+  updateByCfg(cfgModel: RequestCfgModel, reqModel: RequestModel) {
+    const updateCfgMap = cfgModel.updateCfg;
+    if (isEmpty(updateCfgMap)) {
+      return;
+    }
+
+    const keys = Object.keys(updateCfgMap);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i]; // data.name
+      const updateCfg = updateCfgMap[key];
+      this.updateByJsonObject(updateCfg, key, reqModel);
+    }
+  }
+
+  private updateByJsonObject(updateCfg: IFuncCfgModel, key: string, reqModel: RequestModel) {
+    if (isEmpty(updateCfg)) {
+      return;
+    }
+    const itemOldValue = _.get(reqModel, key);
+    const newValue = this.getUpdateNewValueByCfg(updateCfg, itemOldValue, key, reqModel);
+    _.set(reqModel, key, newValue);
+  }
+
+  private getUpdateNewValueByCfg(updateCfg: IFuncCfgModel, itemOldValue: any, key: string, reqModel: RequestModel) {
+    if (!checkFuncCfgValid(updateCfg)) {
+      throw new CommonException(Exceptions.CFG_UPDATE_ITEM_MUST_FUNC_CFG, 'updateCfg配置项必须是满足IFuncCfgModel' + key);
+    }
+
+    let result;
+
+    try {
+      const exeFunCtx = new FuncContext();
+
+      exeFunCtx.currentValue = itemOldValue;
+      exeFunCtx.reqModel = reqModel;
+
+      result = this.serviceHub.executeFuncCfg(updateCfg, exeFunCtx);
+    } catch (e) {
+      this.logger.error('getUpdateNewValueByCfg->executeFuncCfg', e);
+      throw new CommonException(Exceptions.UPDATE_EXCEPTION, key + '.' + e);
+    }
+
+    return result;
+  }
+}
+
+export { CrudProFieldUpdateService };

package/src/libs/crud-pro/services/CrudProFieldValidateService.ts

@@ -0,0 +1,180 @@
+import { RequestModel } from '../models/RequestModel';
+import { CrudProServiceBase } from './CrudProServiceBase';
+import { RequestCfgModel } from '../models/RequestCfgModel';
+import { MixinUtils } from '../utils/MixinUtils';
+import { KeysOfConditions, KeysOfValidators } from '../models/keys';
+import { CommonException, Exceptions } from '../exceptions';
+import { ModelUtils } from '../utils/ModelUtils';
+import { ICustomValidateFunc, IFuncCfgModel, IValidatorCfgItem } from '../interfaces';
+import { FuncContext } from '../models/FuncContext';
+import { validateByCfgString } from '../utils/ValidateUtils';
+
+const { checkFuncCfgValid } = ModelUtils;
+
+const { isEmpty, isNotEmpty, deepTravelObject } = MixinUtils;
+
+class CrudProFieldValidateService extends CrudProServiceBase {
+  validateByAllow(cfgModel: RequestCfgModel, reqModel: RequestModel) {
+    const allowCfg = cfgModel.allowCfg; //  allowCfg: {data: ['login_name', 'nick_name', 'avatar', 'status'],},
+    if (isEmpty(allowCfg)) {
+      return;
+    }
+
+    const keys = Object.keys(allowCfg);
+
+    const validateAllowByJsonObject = (allowList: string[], targetObj: any, key: string) => {
+      if (isEmpty(allowList)) {
+        return;
+      }
+
+      const isCondition = key.startsWith('condition');
+
+      // 任意一个key，不在allow列表中，就不合法
+      deepTravelObject(
+        targetObj,
+        (value, key, index, keyPath) => {
+          if (isCondition) {
+            if (!KeysOfConditions.ALL_KEYS.has(key) && !allowList.includes(key)) {
+              throw new CommonException(Exceptions.VALIDATE_ALLOW_ERR, keyPath);
+            }
+          } else {
+            if (!allowList.includes(key)) {
+              throw new CommonException(Exceptions.VALIDATE_ALLOW_ERR, keyPath);
+            }
+          }
+        },
+        key
+      );
+    };
+
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i]; // demo: data or condition
+      const allowList = MixinUtils.parseStringArray(allowCfg[key]);
+      if (Array.isArray(allowList) && allowList.length > 0) {
+        const targetObj = reqModel.getCondOrDataJsonObject(key);
+        validateAllowByJsonObject(allowList, targetObj, key);
+      }
+    }
+  }
+
+  validateByReject(cfgModel: RequestCfgModel, reqModel: RequestModel) {
+    const rejectCfgMap = cfgModel.rejectCfg;
+    if (isEmpty(rejectCfgMap)) {
+      return;
+    }
+
+    const keys = Object.keys(rejectCfgMap);
+
+    const validateRejectByJsonObject = (rejectList: string[], targetObj: any, conditionName: string) => {
+      if (isEmpty(rejectList)) {
+        return;
+      }
+      // 任意一个key，出现在reject列表中，就不合法
+      deepTravelObject(
+        targetObj,
+        (value, key, index, keyPath) => {
+          if (rejectList.includes(key)) {
+            throw new CommonException(Exceptions.VALIDATE_REJECT_ERR, keyPath);
+          }
+        },
+        conditionName
+      );
+    };
+
+    for (let i = 0; i < keys.length; i++) {
+      const conditionName = keys[i];
+      const rejectList = MixinUtils.parseStringArray(rejectCfgMap[conditionName]);
+      if (Array.isArray(rejectList) && rejectList.length > 0) {
+        const targetObj = reqModel.getCondOrDataJsonObject(conditionName);
+        validateRejectByJsonObject(rejectList, targetObj, conditionName);
+      }
+    }
+  }
+
+  validateByCfg(cfgModel: RequestCfgModel, reqModel: RequestModel) {
+    const validateCfg = cfgModel.validateCfg;
+    if (isEmpty(validateCfg)) {
+      return;
+    }
+    const keys = Object.keys(validateCfg);
+    for (const key of keys) {
+      const itemValue = reqModel.getJsonObjectValue(key);
+      const cfgList = validateCfg[key];
+
+      if (isNotEmpty(cfgList)) {
+        // 先校验是否必填。
+        this.validateRequired(cfgList, itemValue, key);
+
+        // 除REQUIRED之外的其他配置
+        const cfgList2 = cfgList.filter(cfg => {
+          return cfg !== KeysOfValidators.REQUIRED;
+        });
+
+        // 只有数值不为空时，才需要校验。非必填情况下：内容为空，不需要校验
+        if (isNotEmpty(itemValue)) {
+          for (const cfg of cfgList2) {
+            if (typeof cfg === 'string') {
+              this.validateByCfgString(cfg, reqModel, itemValue, key);
+            } else if (typeof cfg === 'function') {
+              this.validateByCfgCustomFunction(cfg, reqModel, itemValue, key);
+            } else {
+              this.validateByCfgFunc(cfg, reqModel, itemValue, key);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  private validateByCfgCustomFunction(cfg: ICustomValidateFunc, reqModel: RequestModel, itemValue: any, key: string) {
+    // 使用自定义函数校验
+    cfg(itemValue);
+  }
+
+  private validateByCfgString(itemCfg: KeysOfValidators | string, reqModel: RequestModel, itemValue: any, errPath: string) {
+    return validateByCfgString(itemCfg, itemValue, errPath);
+  }
+
+  private validateByCfgFunc(funcCfg: IFuncCfgModel, reqModel: RequestModel, itemValue: any, errPath: string) {
+    if (!checkFuncCfgValid(funcCfg)) {
+      throw new CommonException(Exceptions.CFG_VALIDATE_CUSTOM_FUNCTION_EMPTY);
+    }
+
+    let result;
+
+    try {
+      const exeFunCtx = new FuncContext();
+
+      exeFunCtx.currentValue = itemValue;
+      exeFunCtx.reqModel = reqModel;
+
+      result = this.serviceHub.executeFuncCfg(funcCfg, exeFunCtx);
+    } catch (e) {
+      this.logger.error('validateByCfgFunc', e);
+      throw new CommonException(Exceptions.VALIDATE_EXCEPTION, errPath + '.' + e);
+    }
+
+    if (!(typeof result === 'boolean')) {
+      // 自定义的校验函数，必须返回boolean类型的树枝
+      throw new CommonException(Exceptions.CFG_VALIDATE_CUSTOM_FUNCTION_MUST_RETURN_BOOL, errPath);
+    }
+
+    if (result === false) {
+      throw new CommonException(Exceptions.VALIDATE_ERR, funcCfg.message || errPath);
+    }
+  }
+
+  private validateRequired(cfgList: IValidatorCfgItem[], itemValue: any, errPath: string) {
+    const required = cfgList.find(cfg => {
+      return cfg === KeysOfValidators.REQUIRED;
+    });
+
+    if (required) {
+      if (isEmpty(itemValue)) {
+        throw new CommonException(Exceptions.VALIDATE_ERR, '参数校验错误，缺少必填字段：' + errPath);
+      }
+    }
+  }
+}
+
+export { CrudProFieldValidateService };