workflow-editor 0.0.90-up-cdnTmp1 → 0.0.91-up

package/packages/plugins/formValidatorUtil.js

@@ -0,0 +1,890 @@
+import Validator from 'async-validator'
+import { getI18n } from '../workflow-editor/src/util'
+import { parseSubTablePermissionCondition } from 'agilebuilder-ui/src/utils/calculator/calculator-util'
+function getLeafPropRule(editField, dataTypeMap) {
+  const rule = {}
+  const dataType = editField.dataType
+  if (dataType === 'DATE' || dataType === 'TIME') {
+    // 对象的值需要是毫秒值数字
+    // if (editField.valueType && editField.valueType === 'number') {
+    //   // 表示值是毫秒值
+    //   rule.type = 'number'
+    // }
+    rule.type = 'date'
+    packageCustomValidator(rule)
+    rule.message = editField.label + ' ' + getI18n().t('workflowEditorMessage.requiredAndMustBeADate')
+  } else if (dataType === 'INTEGER' || dataType === 'LONG') {
+    // rule.type = 'number'
+    rule.pattern = /^-?\d+$/
+    rule.message = editField.label + ' ' + getI18n().t('workflowEditorMessage.requiredAndMustBeAnInteger')
+  } else if (dataType === 'FLOAT' || dataType === 'DOUBLE') {
+    rule.pattern = new RegExp('^(-?\\d+)(\\.\\d+)?$')
+    rule.message = editField.label + ' ' + getI18n().t('workflowEditorMessage.requiredAndMustBeDecimal')
+  } else if (dataType === 'BOOLEAN') {
+    rule.type = 'boolean'
+    rule.message = editField.label + ' ' + getI18n().t('workflowEditorMessage.mustFill')
+    // 布尔型校验需要自定义，为了兼容oracle和mysql数据
+    packageCustomValidator(rule)
+  } else {
+    // if (entity[editField.name] || entity[editField.name] === 0) {
+    //   if (typeof entity[editField.name] === 'number' && dataType === 'TEXT') {
+    //     rule.type = 'number'
+    //   }
+    // }
+    rule.message = editField.label + ' ' + getI18n().t('workflowEditorMessage.mustFill')
+  }
+  if (editField.canEdit) {
+    rule.required = true
+    // 失去焦点时触发
+    rule.trigger = 'blur'
+  }
+  if (editField.rowIndexes) {
+    // 子表时受控制的行记录下标
+    rule.rowIndexes = editField.rowIndexes
+  }
+  if (editField.condition) {
+    // 必填条件
+    rule.condition = editField.condition
+  }
+  dataTypeMap[editField.name] = editField.dataType
+  return rule
+}
+
+/**
+ * 布尔型和日期校验需要自定义，为了兼容oracle和mysql数据库
+ * @param fieldRule
+ */
+function packageCustomValidator(fieldRule) {
+  if (fieldRule && fieldRule.type && fieldRule.type === 'boolean') {
+    fieldRule.validator = function (rule, value, callback) {
+      if (value === undefined || value === null) {
+        if (rule.required) {
+          return false
+        } else {
+          return true
+        }
+      } else if (typeof value === 'number' && (value === 1 || value === 0)) {
+        return true
+      } else if (typeof value === 'boolean' && (value === true || value === false)) {
+        return true
+      }
+      return false
+    }
+  } else if (fieldRule && fieldRule.type && fieldRule.type === 'date') {
+    fieldRule.validator = function (rule, value, callback) {
+      if (value === undefined || value === null) {
+        if (rule.required) {
+          return false
+        } else {
+          return true
+        }
+      } else {
+        // 验证是否是合法日期
+        const date = new Date(value)
+        return !isNaN(date.getTime())
+      }
+    }
+  }
+}
+
+/**
+ * 获得对象验证规则
+ * @param {*} editField  字段信息
+ * @param {*} rules 验证规则
+ */
+function setObjectPropRule(editField, rules, isSql, dataTypeMap) {
+  const rule = {}
+  let prop = editField.name
+  if (isSql === true) {
+    prop = underscoreName(prop)
+  }
+  if (!rules) {
+    rules = {}
+  }
+  const props = prop.split('.')
+  for (let num = 0; num < props.length; num++) {
+    const subProp = props[num]
+    let objectRule
+    if (num === props.length - 1) {
+      // 说明是最后一个
+      objectRule = getEndObjectRule(rule, props, subProp)
+      objectRule.fields[subProp] = getLeafPropRule(editField, dataTypeMap)
+    } else {
+      let lastObjectRule
+      if (num === 0) {
+        objectRule = rules
+      } else {
+        lastObjectRule = getLastObjectRule(rule, props, props[num - 1])
+        objectRule = lastObjectRule.fields
+      }
+      if (!objectRule[subProp]) {
+        objectRule[subProp] = {
+          type: 'object',
+          required: true,
+          fields: {}
+        }
+      }
+      if (num === 0) {
+        rule[subProp] = objectRule[subProp]
+      } else {
+        lastObjectRule.fields[subProp] = objectRule[subProp]
+      }
+    }
+  }
+}
+
+function getLastObjectRule(rule, props, currentProp) {
+  let lastObjectdRule
+  for (let i = 0; i < props.length; i++) {
+    const subProp = props[i]
+    if (i === 0) {
+      lastObjectdRule = rule[subProp]
+    } else {
+      lastObjectdRule = lastObjectdRule.fields[props[i]]
+    }
+    if (subProp === currentProp) {
+      break
+    }
+  }
+  return lastObjectdRule
+}
+
+function getEndObjectRule(rule, props, currentProp) {
+  let lastObjectdRule
+  for (let i = 0; i < props.length; i++) {
+    if (i === 0) {
+      lastObjectdRule = rule[props[i]]
+    } else {
+      lastObjectdRule = lastObjectdRule.fields[props[i]]
+    }
+    if (i !== props.length - 1) {
+      const leafSubProp = props[i + 1]
+      if (leafSubProp === currentProp) {
+        break
+      }
+    }
+  }
+  return lastObjectdRule
+}
+
+/**
+ * 获得主表及子表验证规则
+ * @param {editFieldInfos} editFieldInfos 编辑字段信息集合
+ * @param {entity} entity 当前表单数据model
+ * @param {isSql} isSql 是否是sql操作流程表单，如果是字段名需要修改为下划线命名规则
+ */
+function getValidator(editFieldInfos, entity, isSql, additionalParamMap, taskParamMap, contextParameter) {
+  // console.log('workflowEditor-getValidator-editFieldInfos=', editFieldInfos, 'entity=', entity, 'isSql', isSql)
+  if (typeof isSql === 'undefined') {
+    isSql = false
+  }
+  // 主表验证规则
+  const rules = {}
+  // 子表验证规则，格式为：
+  // {prop:
+  //   {subField1:{required: true},
+  //   subField2:{required: true}
+  //   }
+  // }
+  // 子表整个表的权限
+  // {
+  //  子表表名1:{required:true/false(必填/禁止编辑),message:'xxx子表必需录入数据'},
+  //  子表表名2:{required:true/false(必填/禁止编辑),message:'xxx子表必需录入数据'}
+  // }
+  const dataTypeMap = {}
+  const totalSubRules = {}
+  const subRules = {}
+  if (editFieldInfos) {
+    editFieldInfos.forEach((editField) => {
+      const canEdit = editField.canEdit
+      // 必填
+      if (typeof canEdit !== 'undefined' && canEdit === true) {
+        let prop = editField.name
+        if (prop) {
+          if (isSql === true) {
+            prop = underscoreName(prop)
+          }
+          const condition = editField.condition
+          const parentFormData = null
+          let result = null
+          if (prop.indexOf('.') > 0 && prop.indexOf('$') === 0) {
+            // 当是子表记录时候 result设置为true 获取行记录校验条件
+            result = true
+          } else {
+            result = parseSubTablePermissionCondition(
+              condition,
+              dataTypeMap,
+              parentFormData,
+              entity,
+              additionalParamMap,
+              taskParamMap,
+              contextParameter
+            )
+          }
+          if (result !== undefined && result !== null && result === true) {
+            let rule = {}
+            if (prop.indexOf('.') > 0) {
+              if (prop.indexOf('$') === 0) {
+                // 表示是子表字段
+                setSubObjectFieldRule(editField, subRules, entity, isSql, dataTypeMap)
+              } else {
+                // 表示是主表的关联属性字段。
+                setMainObjectFieldRule(editField, rules, entity, isSql, dataTypeMap)
+              }
+            } else if (prop.indexOf('$') === 0) {
+              // 表示是子表整个表的权限
+              // 获得子表表名
+              const subTable = prop.substring(prop.indexOf('$') + 1)
+              totalSubRules[subTable] = {
+                required: true,
+                message: getI18n().t('workflowEditorMessage.subTableMustInputDatas', {
+                  subTable: editField.label
+                })
+              }
+            } else {
+              // 表示是主表的直接属性
+              rule = getLeafPropRule(editField, dataTypeMap, entity)
+              rules[prop] = rule
+            }
+          }
+        }
+      }
+    })
+  }
+  // console.log('rules', rules, 'subRules=', subRules, 'totalSubRules=', totalSubRules)
+  const subRulesKeys = Object.keys(subRules)
+  if (subRulesKeys.length > 0 || Object.keys(totalSubRules).length > 0) {
+    // 表示有子表规则
+    return {
+      rules,
+      subRules,
+      totalSubRules,
+      dataTypeMap
+    }
+  } else {
+    // 表示只有主表规则
+    return rules
+  }
+}
+
+/**
+ * 设置主对象字段验证规则
+ */
+function setMainObjectFieldRule(editField, rules, entity, isSql, dataTypeMap) {
+  // 例如：a.b.c
+  let prop = editField.name
+  if (isSql === true) {
+    prop = underscoreName(prop)
+  }
+  // 获得a
+  const mainProp = prop.substring(0, prop.indexOf('.'))
+  if (entity) {
+    if (!entity[mainProp]) {
+      entity[mainProp] = {}
+    }
+    const mainEntity = entity[mainProp]
+    // 说明这个字段是该表单的字段，才需要添加验证
+    // 不是该表单的字段的情况，可能是被数据表删除的字段，但是没有修改流程图表单字段权限设置导致的
+    // 获得b.c
+    const mainSubProp = prop.substring(prop.indexOf('.') + 1)
+    if (isNeedValidate(mainSubProp, mainEntity)) {
+      // 需要验证该字段，表示是表单的字段
+      setObjectPropRule(editField, rules, isSql, dataTypeMap)
+    }
+  }
+}
+
+/**
+ * 是否需要验证该属性，例如：b.c 或 a
+ * @param {*} mainSubProp 字段信息，例如：字段为：a.b.c，则mainSubProp应为b.c
+ * @param {*} mainEntity
+ */
+function isNeedValidate(mainSubProp, mainEntity) {
+  // 表示由可以必填
+  if (mainSubProp.indexOf('.') > 0) {
+    let parentObject = mainEntity
+    const subProps = mainSubProp.split('.')
+    for (let num = 0; num < subProps.length - 1; num++) {
+      const subProp = subProps[num]
+      if (!parentObject || !parentObject[subProp]) {
+        // 当前对象不存在，不是该表单的字段，不需要验证
+        return false
+      }
+      // 重新给"父对象"赋值，为下次循环准备
+      parentObject = parentObject[subProp]
+    }
+    return true
+  } else {
+    return true
+  }
+}
+
+function setSubObjectFieldRule(editField, subRules, entity, isSql, dataTypeMap) {
+  let prop = editField.name
+  if (isSql === true) {
+    prop = underscoreName(prop)
+  }
+  // 获得主表字段名称
+  const mainProp = prop.substring(prop.indexOf('$') + 1, prop.indexOf('.'))
+  if (!entity) {
+    return
+  }
+  const tableData = entity[mainProp]
+  // V10注释， 因为在gets请求后就来获取校验，此时实体内的子表数据还没有加载完成，所以会导致没有添加上子表的数据校验规则
+  // if (typeof (tableData) === 'undefined' || tableData === null || tableData.length === 0) {
+  //   // 表单中不存在该子表字段，不需要验证
+  //   return
+  // }
+  // 获得子表字段名
+  const subProp = prop.substring(prop.indexOf('.') + 1)
+  // mainProp对应的所有子表字段验证规则信息
+  if (!subRules[mainProp]) {
+    subRules[mainProp] = {}
+  }
+  // 修改属性名为去掉$mainProp的字段名
+  // 此处要重新拷贝一份字段，否则会导致原字段的name信息被修改
+  const copyEditField = JSON.parse(JSON.stringify(editField))
+  copyEditField.name = subProp
+  if (subProp.indexOf('.') > 0) {
+    // 表示关联属性
+    if (typeof tableData !== 'undefined' && tableData === null && tableData.length === 0) {
+      const subEntity = tableData[0]
+      setMainObjectFieldRule(copyEditField, subRules[mainProp], subEntity, isSql, dataTypeMap)
+    }
+  } else {
+    // 表示是子表的直接属性
+    subRules[mainProp][subProp] = getLeafPropRule(copyEditField, dataTypeMap)
+  }
+}
+
+function validator(entity, validateRules, rowIndex, isSql, pageNum, pageRowIndex, isNeedField, otherParams) {
+  return validatorEntity(entity, validateRules, rowIndex, true, isSql, pageNum, pageRowIndex, isNeedField, otherParams)
+}
+/**
+ *
+ * @param {*} entity
+ * @param {*} validateRules
+ * @param {*} rowIndex
+ * @param {*} isShouldRepeateValdate 是否需要再次验证大写字段名
+ * @returns
+ */
+function validatorEntity(
+  entity,
+  validateRules,
+  rowIndex,
+  isShouldRepeateValdate,
+  isSql,
+  pageNum,
+  pageRowIndex,
+  isNeedField,
+  otherParams
+) {
+  let result = false
+  const validator = new Validator(validateRules)
+  let fieldName
+  let returnAllErrors = false // 是否返回所有错误信息，默认只返回第一个错误信息
+  if (otherParams && otherParams.returnAllErrors !== undefined && otherParams.returnAllErrors === true) {
+    returnAllErrors = true
+  }
+  // returnAllErrors 模式下收集所有错误
+  const allErrors = []
+  validator.validate(
+    entity,
+    {
+      first: !returnAllErrors
+    },
+    (errors, fields) => {
+      if (errors) {
+        if (returnAllErrors) {
+          // 返回所有错误
+          errors.forEach((err) => {
+            const myResult = {
+              message: err.message,
+              field: err.field,
+              pageRowIndex: pageRowIndex
+            }
+            if (pageNum !== null && pageNum !== undefined && pageRowIndex !== null && pageRowIndex !== undefined) {
+              myResult.pageNum = pageNum
+              myResult.rowIndex = pageRowIndex
+            } else if (pageRowIndex === null || pageRowIndex === undefined) {
+              myResult.rowIndex = rowIndex
+            }
+            allErrors.push(myResult)
+          })
+        } else {
+          const message = errors[0]['message']
+          fieldName = errors[0]['field']
+          if (typeof rowIndex !== 'undefined' && rowIndex !== null) {
+            // 表示是子表字段验证失败
+            if (pageNum !== undefined && pageRowIndex !== undefined) {
+              // 表示子表分页时的验证提示信息
+              result =
+                getI18n().t('workflowEditorMessage.pageRecordLine', {
+                  pageNum: pageNum,
+                  row: pageRowIndex
+                }) +
+                '，' +
+                message
+            } else {
+              result =
+                getI18n().t('workflowEditorMessage.recordLine', {
+                  row: rowIndex + 1
+                }) +
+                '，' +
+                message
+            }
+          } else {
+            // 表示是主表字段验证失败
+            result = message
+          }
+        }
+      } else {
+        result = true
+      }
+      if (!returnAllErrors && fieldName && isShouldRepeateValdate === true) {
+        // 将实体中字段名改为大写，然后再验证一次该字段是否已填值。因为mysql中jdbc获得实体记录字段名是小写的，但是验证规则中字段名是大写的，所以会导致字段验证失败
+        const reg1 = /[A-Z]+/ // 大写字母
+        if (
+          isSql !== undefined &&
+          isSql === true &&
+          reg1.test(fieldName) &&
+          entity[fieldName.toLowerCase()] !== undefined
+        ) {
+          const copyEntity = JSON.parse(JSON.stringify(entity))
+          copyEntity[fieldName.toUpperCase()] = entity[fieldName.toLowerCase()]
+          delete copyEntity[fieldName.toLowerCase()]
+          result = validatorEntity(
+            copyEntity,
+            validateRules,
+            rowIndex,
+            false,
+            isSql,
+            pageNum,
+            pageRowIndex,
+            isNeedField,
+            otherParams
+          )
+        }
+      }
+    }
+  )
+
+  if (returnAllErrors) {
+    return allErrors
+  }
+
+  if (isNeedField) {
+    let myResult = { msg: result, field: fieldName }
+    if (pageNum !== undefined && pageRowIndex !== undefined) {
+      myResult.pageNum = pageNum
+      myResult.rowIndex = pageRowIndex
+    } else {
+      myResult.rowIndex = rowIndex
+    }
+    return myResult
+  } else {
+    return result
+  }
+}
+
+/**
+ * 验证子表必填验证
+ * @param {*}} entity
+ * @param {*} subRules
+ * @param {*} subTablePageInfo 列表分页信息{列表编码: 每页显示多少条记录}
+ */
+function validateSub(
+  entity,
+  subRules,
+  totalSubRules,
+  isSql,
+  dataTypeMap,
+  additionalParamMap,
+  taskParamMap,
+  contextParameter,
+  subTablePageInfo,
+  isNeedField,
+  otherParams
+) {
+  let copyTotalSubRules = {}
+  if (totalSubRules) {
+    copyTotalSubRules = JSON.parse(JSON.stringify(totalSubRules))
+  }
+  let returnAllErrors = false // 是否返回所有错误信息，默认只返回第一个错误信息
+  if (otherParams && otherParams.returnAllErrors !== undefined && otherParams.returnAllErrors === true) {
+    returnAllErrors = true
+  }
+  // returnAllErrors 模式下收集所有子表错误
+  const allSubErrors = []
+
+  if (subRules) {
+    console.log('formValidator333--subRules=', subRules)
+    const subProps = Object.keys(subRules)
+    for (let i = 0; i < subProps.length; i++) {
+      const prop = subProps[i]
+      const subFieldRule = subRules[prop]
+      console.log('formValidator44--subFieldRule=', subFieldRule)
+      // 受控制的行下标集合
+      const subFieldProps = Object.keys(subFieldRule)
+      console.log('formValidator555--subFieldProps=', subFieldProps)
+      let subTableData = entity[prop]
+      if (!subTableData) {
+        // 如果子表集合数据不存在
+        subTableData = []
+      }
+      // 验证整个子表是否已填记录，如果是必填，但是没有子记录集合，则提示
+      const validateResult = validateTotalSubTable(copyTotalSubRules, entity, prop)
+      if (validateResult !== true) {
+        delete copyTotalSubRules[prop]
+        if (returnAllErrors) {
+          allSubErrors.push({
+            message: validateResult,
+            listCode: prop
+          })
+          // 继续检查其他子表
+          continue
+        }
+        if (isNeedField) {
+          return { msg: validateResult, listCode: prop }
+        } else {
+          return validateResult
+        }
+      }
+      let pageSize
+      let hasAuthFields = []
+      if (subTablePageInfo && subTablePageInfo[prop]) {
+        pageSize = subTablePageInfo[prop].pageSize
+        hasAuthFields = subTablePageInfo[prop].fields || []
+      }
+      for (let j = 0; j < subTableData.length; j++) {
+        const rowData = subTableData[j]
+        const rowRule = packageRowRule(
+          subFieldProps,
+          subFieldRule,
+          subTableData[j],
+          dataTypeMap,
+          entity,
+          additionalParamMap,
+          taskParamMap,
+          contextParameter,
+          hasAuthFields
+        )
+        console.log('formValidator666--rowRule=', rowRule)
+        let pageNum
+        // 每页的记录下标，提示时使用
+        let pageRowIndex
+        if (pageSize !== undefined && pageSize > 0) {
+          pageNum = Math.ceil((j + 1) / pageSize)
+          pageRowIndex = j + 1 - (pageNum - 1) * pageSize
+        }
+        Object.keys(rowRule).forEach((field) => {
+          const fieldRule = rowRule[field]
+          if (fieldRule && fieldRule.rules) {
+            // 如果有rules规则，则将rules规则添加到rowRule中 ,为了统一表单和子表的校验规则传递参数方式
+            rowRule[field] = fieldRule.rules
+          }
+          if (fieldRule && fieldRule.beforeValidate) {
+            // 如果有beforeValidate方法，则执行
+            const beforeValidate = fieldRule.beforeValidate
+            if (typeof beforeValidate === 'function') {
+              const result = beforeValidate({
+                row: rowData,
+                parent: entity,
+                rowIndex: j
+              })
+              // 如果是false，表示当前规则不需要在当前行验证，
+              // 移除当前规则，其他行还是要根据beforeValidate的返回值判断是否需要验证
+              if (result === false) {
+                rowRule[field] = []
+              }
+            }
+          }
+        })
+        const validateResult = validator(rowData, rowRule, j, isSql, pageNum, pageRowIndex, isNeedField, otherParams)
+        if (returnAllErrors) {
+          // 当前行的所有错误
+          if (validateResult && validateResult.length > 0) {
+            validateResult.forEach((err) => {
+              if (subTablePageInfo[prop] && subTablePageInfo[prop].title) {
+                err.message = subTablePageInfo[prop].title + '：' + err.message
+              }
+              err.listCode = prop
+              allSubErrors.push(err)
+            })
+          }
+        } else {
+          if ((!isNeedField && validateResult !== true) || (isNeedField && validateResult.msg !== true)) {
+            // 表示验证失败，无需继续验证
+            if (isNeedField) {
+              if (subTablePageInfo[prop].title) {
+                // 如果有子表标题，则添加子表标题
+                validateResult.msg = subTablePageInfo[prop].title + '：' + validateResult.msg
+              }
+              validateResult.listCode = prop
+            }
+            return validateResult
+          }
+        }
+      }
+    }
+  }
+
+  for (const subTableName in copyTotalSubRules) {
+    const validateResult = validateTotalSubTable(copyTotalSubRules, entity, subTableName)
+    if (validateResult !== true) {
+      if (returnAllErrors) {
+        allSubErrors.push({
+          message: validateResult,
+          listCode: subTableName
+        })
+        continue
+      }
+      if (isNeedField) {
+        return { msg: validateResult, listCode: subTableName }
+      } else {
+        return validateResult
+      }
+    }
+  }
+  if (returnAllErrors) {
+    return allSubErrors
+  }
+  return isNeedField ? { msg: true } : true
+}
+
+function getEntityId(row) {
+  if (row && row.id) {
+    return row.id
+  } else if (row && row.ID) {
+    return row.ID
+  }
+}
+
+/**
+ * 封装行记录的验证规则
+ * @param {*}} subProps
+ * @param {*} subFieldRule
+ * @param {*} rowIndex
+ * @returns
+ */
+function packageRowRule(
+  subProps,
+  subFieldRule,
+  row,
+  dataTypeMap,
+  parentFormData,
+  additionalParamMap,
+  taskParamMap,
+  contextParameter,
+  hasAuthFields
+) {
+  const rowId = getEntityId(row)
+  const rowRule = {}
+  for (let n = 0; n < subProps.length; n++) {
+    const field = subProps[n]
+    if (hasAuthFields.indexOf(field) < 0) {
+      // 如果没有权限编辑该字段，则不需要验证
+      continue
+    }
+    const fieldRule = subFieldRule[field]
+    const condition = fieldRule.condition
+    const result = parseSubTablePermissionCondition(
+      condition,
+      dataTypeMap,
+      parentFormData,
+      row,
+      additionalParamMap,
+      taskParamMap,
+      contextParameter
+    )
+    if (result !== undefined && result !== null && result === true) {
+      // 表示由可以必填
+      if (rowId === undefined) {
+        // 表示是新建的记录，需要验证
+        rowRule[field] = fieldRule
+      } else {
+        // 表示是已保存的记录，验证id是否在可修改的集合内
+        const rowIndexes = fieldRule.rowIndexes
+        if (!rowIndexes || rowIndexes.indexOf(rowId) >= 0) {
+          // 表示该行记录的该字段需要做必填验证
+          rowRule[field] = fieldRule
+        }
+      }
+    }
+  }
+  return rowRule
+}
+
+// 验证整个子表是否已填记录
+function validateTotalSubTable(totalSubRules, entity, subTableName) {
+  let subTableData = entity[subTableName]
+  if (!subTableData) {
+    // 如果子表集合数据不存在
+    subTableData = []
+  }
+  if (
+    subTableData.length === 0 &&
+    totalSubRules &&
+    totalSubRules[subTableName] &&
+    totalSubRules[subTableName].required !== undefined &&
+    totalSubRules[subTableName].required === true
+  ) {
+    return totalSubRules[subTableName].message
+  }
+  return true
+}
+/**
+ *
+ * @param {*} entity
+ * @param {*} validateRules
+ * @param {*} isSql
+ * @param {*} additionalParamMap
+ * @param {*} taskParamMap
+ * @param {*} contextParameter
+ * @param {*} subTablePageInfo
+ * @param {*} isNeedField  如果为true，表示返回的是{}对象，msg: true/提示信息、field：字段名
+ * @returns
+ */
+function formValidator(
+  entity,
+  validateRules,
+  isSql,
+  additionalParamMap,
+  taskParamMap,
+  contextParameter,
+  subTablePageInfo,
+  isNeedField,
+  otherParams
+) {
+  let returnAllErrors = false // 是否返回所有错误信息，默认只返回第一个错误信息
+  if (otherParams && otherParams.returnAllErrors !== undefined && otherParams.returnAllErrors === true) {
+    returnAllErrors = true
+  }
+  if (returnAllErrors) {
+    // 返回所有验证错误
+    const allErrors = []
+
+    //先验证主表字段
+    const mainErrors = validator(entity, validateRules, null, isSql, null, null, isNeedField, otherParams)
+    if (mainErrors && mainErrors.length > 0) {
+      allErrors.push(...mainErrors)
+    }
+
+    const validateRulesKeys = Object.keys(validateRules)
+    // 脚本控制的验证
+    if (
+      validateRulesKeys.indexOf('rules') >= 0 &&
+      validateRulesKeys.indexOf('subRules') >= 0 &&
+      validateRulesKeys.indexOf('totalSubRules') >= 0
+    ) {
+      // 表示是带有子表验证规则的
+      const rules = validateRules.rules
+      const subRules = validateRules.subRules
+      const totalSubRules = validateRules.totalSubRules
+      const dataTypeMap = validateRules.dataTypeMap
+
+      // 验证rules中的主表规则
+      const rulesErrors = validator(entity, rules, null, isSql, null, null, isNeedField, otherParams)
+      if (rulesErrors && rulesErrors.length > 0) {
+        allErrors.push(...rulesErrors)
+      }
+      debugger
+      // 3. 验证子表
+      if (subRules || totalSubRules) {
+        const subErrors = validateSub(
+          entity,
+          subRules,
+          totalSubRules,
+          isSql,
+          dataTypeMap,
+          additionalParamMap,
+          taskParamMap,
+          contextParameter,
+          subTablePageInfo,
+          isNeedField,
+          otherParams
+        )
+        if (subErrors && subErrors.length > 0) {
+          allErrors.push(...subErrors)
+        }
+      }
+    } else if (validateRulesKeys.indexOf('rules') >= 0) {
+      // 表示没有子表验证规则，但有 rules
+      const rules = validateRules.rules
+      const rulesErrors = validator(entity, rules, null, isSql, null, null, isNeedField, otherParams)
+      if (rulesErrors && rulesErrors.length > 0) {
+        allErrors.push(...rulesErrors)
+      }
+    }
+
+    return allErrors
+  }
+  // 仅返回第一个错误
+  // 兼容 workflowRules= { CODE:[{xxxxx}], rules:{},subRules:{}}格式的验证
+  let validateResult = validator(entity, validateRules, null, isSql, null, null, isNeedField, otherParams)
+  if ((!isNeedField && validateResult === true) || (isNeedField && validateResult.msg === true)) {
+    // 先验证流程编辑器配置的字段必填验证
+    const validateRulesKeys = Object.keys(validateRules)
+    // 脚本控制的验证会走下面的验证代码
+    if (
+      validateRulesKeys.indexOf('rules') >= 0 &&
+      validateRulesKeys.indexOf('subRules') >= 0 &&
+      validateRulesKeys.indexOf('totalSubRules') >= 0
+    ) {
+      // 表示是带有子表验证规则的
+      const rules = validateRules.rules
+      const subRules = validateRules.subRules
+      const totalSubRules = validateRules.totalSubRules
+      const dataTypeMap = validateRules.dataTypeMap
+      validateResult = validator(entity, rules, null, isSql, null, null, isNeedField)
+      if ((!isNeedField && validateResult === true) || (isNeedField && validateResult.msg === true)) {
+        if (subRules || totalSubRules) {
+          validateResult = validateSub(
+            entity,
+            subRules,
+            totalSubRules,
+            isSql,
+            dataTypeMap,
+            additionalParamMap,
+            taskParamMap,
+            contextParameter,
+            subTablePageInfo,
+            isNeedField,
+            otherParams
+          )
+        }
+      }
+      return validateResult
+    } else if (validateRulesKeys.indexOf('rules') >= 0) {
+      // 表示没有子表验证规则
+      const rules = validateRules.rules
+      return validator(entity, rules, null, isSql, null, null, isNeedField)
+    }
+  } else {
+    return validateResult
+  }
+}
+
+// 驼峰命名改为下划线命名，例如：helloWord->hello_world
+function underscoreName(name) {
+  // if (name.indexOf('_') > 0) {
+  // 如果包括下划线，表示是下划线命名，需要再转换
+  return name
+  // }
+  // return name.replace(/([A-Z])/g, '_$1').toLowerCase()
+}
+// 下划线命名改为驼峰命名，例如：hello_word->helloWorld
+// function camelName(name) {
+//   if (name.indexOf('_') < 0) {
+//     // 如果不包括下划线不需要转换
+//     return name
+//   }
+//   return name.replace(/_(\w)/g, function(all, letter) {
+//     return letter.toUpperCase()
+//   })
+// }
+
+export default {
+  formValidator,
+  getValidator
+}