workflow-editor 0.9.85-dw-tmp3 → 0.9.87-dw

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "workflow-editor",
-  "version": "0.9.85-dw-tmp3",
+  "version": "0.9.87-dw",
   "description": "流程编辑器",
-  "main": "lib/workflow-editor.min.js",
+  "main": "lib/workflow-editor.umd.min.js",
   "private": false,
   "scripts": {
     "serve": "vue-cli-service serve",
@@ -10,11 +10,7 @@
     "lib": "vue-cli-service build --modern --target lib --name workflow-editor --dest lib packages/index.js",
     "lint": "vue-cli-service lint",
     "test:e2e": "vue-cli-service test:e2e",
-    "test:unit": "vue-cli-service test:unit",
-    "build:style": "gulp --gulpfile build/gen-style.js",
-    "build:prod": "webpack --config build/webpack.prod.js",
-    "build:components": "webpack --config build/webpack.component.js",
-    "dist": "npm run build:prod && npm run build:components"
+    "test:unit": "vue-cli-service test:unit"
   },
   "dependencies": {
     "babel-plugin-prismjs": "^1.0.2",
@@ -24,52 +20,29 @@
     "xml-js": "^1.6.11"
   },
   "devDependencies": {
-    "@babel/core": "^7.5.5",
-    "@babel/plugin-transform-runtime": "^7.5.5",
-    "@babel/preset-env": "^7.5.5",
-    "@gcommon/gcommon-ui": "1.8.0",
     "@vue/cli-plugin-babel": "3.8.0",
-    "@vue/test-utils": "^1.3.6",
+    "@vue/cli-plugin-e2e-cypress": "3.8.0",
+    "@vue/cli-plugin-eslint": "3.8.0",
+    "@vue/cli-plugin-unit-mocha": "3.8.0",
+    "@vue/cli-service": "3.8.0",
+    "@vue/eslint-config-standard": "^4.0.0",
+    "@vue/test-utils": "^1.0.0-beta.29",
     "axios": "0.19.0",
-    "babel-loader": "^8.0.6",
-    "babel-plugin-component": "^1.1.1",
-    "chai": "^4.2.0",
-    "cross-env": "^5.2.0",
-    "css-loader": "2.1.1",
-    "file-loader": "^4.2.0",
-    "gh-pages": "^2.1.1",
-    "gulp": "^4.0.2",
-    "gulp-autoprefixer": "^7.0.0",
-    "gulp-clean-css": "^4.2.0",
-    "gulp-rename": "^1.4.0",
-    "gulp-sass": "^4.0.2",
-    "imatrix-ui": "2.9.0-dw-tmp13",
-    "karma": "^4.2.0",
-    "karma-chai": "^0.1.0",
-    "karma-chrome-launcher": "^3.1.0",
-    "karma-coverage": "^2.0.1",
-    "karma-mocha": "^1.3.0",
-    "karma-sinon-chai": "^2.0.2",
-    "karma-sourcemap-loader": "^0.3.7",
-    "karma-spec-reporter": "^0.0.32",
-    "karma-webpack": "^4.0.2",
-    "less": "^3.10.2",
-    "less-loader": "^5.0.0",
-    "mocha": "^6.2.0",
-    "node-sass": "^4.12.0",
-    "rimraf": "^3.0.0",
-    "sass-loader": "^7.3.1",
+    "babel-eslint": "^10.0.1",
+    "chai": "4.2.0",
+    "element-ui": "2.15.3",
+    "eslint": "5.16.0",
+    "eslint-plugin-vue": "5.2.2",
+    "imatrix-ui": "2.9.8-dw",
+    "node-sass": "4.12.0",
+    "nprogress": "^0.2.0",
+    "sass-loader": "^7.1.0",
     "sessionstorage": "^0.1.0",
-    "sinon": "^7.4.1",
-    "sinon-chai": "^3.3.0",
-    "style-loader": "^0.23.1",
-    "url-loader": "^2.1.0",
+    "vue": "^2.6.10",
+    "vue-cli-plugin-element": "^1.0.1",
     "vue-i18n": "^8.17.4",
-    "vue-loader": "^15.7.1",
-    "vue-style-loader": "^4.1.2",
-    "vuepress": "^1.0.3",
-    "vuex": "^3.1.1",
-    "webpack": "^4.39.2",
-    "webpack-cli": "^3.3.7"
+    "vue-router": "^3.0.6",
+    "vue-template-compiler": "^2.6.10",
+    "vuex": "^3.1.1"
   }
 }

package/{src → packages}/index.js

@@ -1,22 +1,22 @@
 // 依次导入组件库的各个组件
-import workflow from '../packages/workflow-editor'
+import workflow from './workflow-editor'
 import formValidator from './../packages/plugins/index'
-// const WorkflowEditor = workflow.WorkflowEditor
+const WorkflowEditor = workflow.WorkflowEditor
 const WorkflowHistory = workflow.WorkflowHistory
 const wfEditorStore = workflow.wfEditorStore
 
 // 将所有组件都存储起来,方便后续统一注册
-// const components = [
-//   WorkflowEditor,
-//   WorkflowHistory
-// ]
+const components = [
+  WorkflowEditor,
+  WorkflowHistory
+]
 
 // 定义 install 方法，接收 Vue 作为参数。如果使用 use 注册插件，则所有的组件都将被注册
 const install = function(Vue) {
   if (install.installed) return
-  // components.forEach(component => {
-  //   Vue.component(component.name, component)
-  // })
+  components.forEach(component => {
+    Vue.component(component.name, component)
+  })
   // components.map(component => Vue.component(component.name, component))
   Vue.use(formValidator)
 }
@@ -26,12 +26,9 @@ if (typeof window !== 'undefined' && window.Vue) {
   install(window.Vue)
 }
 
-export {
-  WorkflowHistory,
-  wfEditorStore
-}
-
 export default {
   // 导出的对象必须具有 install，才能被 Vue.use() 方法安装
-  install
+  install,
+  WorkflowEditor,
+  wfEditorStore
 }

package/packages/plugins/formValidatorUtil.js

@@ -0,0 +1,528 @@
+import Validator from 'async-validator'
+import {
+  getI18n
+} from '../workflow-editor/src/util'
+import {
+  parseSubTablePermissionCondition
+} from 'imatrix-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.message = editField.label + ' ' + getI18n().t('workflowEditorMessage.requiredAndMustBeADate')
+  } else if (dataType === 'INTEGER' || dataType === 'LONG') {
+    rule.type = 'number'
+    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.message = editField.label + ' ' + getI18n().t('workflowEditorMessage.mustFill')
+  } else {
+    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
+}
+
+/**
+ * 获得对象验证规则
+ * @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)
+              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]
+  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) {
+    // 表示关联属性
+    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) {
+  return validatorEntity(entity, validateRules, rowIndex, true, isSql, pageNum, pageRowIndex)
+}
+/**
+ *
+ * @param {*} entity
+ * @param {*} validateRules
+ * @param {*} rowIndex
+ * @param {*} isShouldRepeateValdate 是否需要再次验证大写字段名
+ * @returns
+ */
+function validatorEntity(entity, validateRules, rowIndex, isShouldRepeateValdate, isSql, pageNum, pageRowIndex) {
+  let result = false
+  const validator = new Validator(validateRules)
+
+  validator.validate(entity, {
+    first: true
+  },
+  (errors, fields) => {
+    let fieldName
+    if (errors) {
+      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 (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)
+      }
+    }
+  })
+
+  return result
+}
+
+/**
+ * 验证子表必填验证
+ * @param {*}} entity
+ * @param {*} subRules
+ * @param {*} subTablePageInfo 列表分页信息{列表编码: 每页显示多少条记录}
+ */
+function validateSub(entity, subRules, totalSubRules, isSql, dataTypeMap, additionalParamMap, taskParamMap, contextParameter, subTablePageInfo) {
+  let copyTotalSubRules = {}
+  if (totalSubRules) {
+    copyTotalSubRules = JSON.parse(JSON.stringify(totalSubRules))
+  }
+  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]
+        return validateResult
+      }
+      let pageSize
+      if (subTablePageInfo && subTablePageInfo[prop]) {
+        pageSize = subTablePageInfo[prop].pageSize
+      }
+      for (let j = 0; j < subTableData.length; j++) {
+        const rowData = subTableData[j]
+        const rowRule = packageRowRule(subFieldProps, subFieldRule, subTableData[j], dataTypeMap, entity, additionalParamMap, taskParamMap, contextParameter)
+        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)
+        }
+        const validateResult = validator(rowData, rowRule, j, isSql, pageNum, pageRowIndex)
+        if (validateResult !== true) {
+          // 表示验证失败，无需继续验证
+          return validateResult
+        }
+      }
+    }
+  }
+
+  for (const subTableName in copyTotalSubRules) {
+    const validateResult = validateTotalSubTable(copyTotalSubRules, entity, subTableName)
+    if (validateResult !== true) {
+      return validateResult
+    }
+  }
+  return 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) {
+  const rowId = getEntityId(row)
+  const rowRule = {}
+  for (let n = 0; n < subProps.length; n++) {
+    const field = subProps[n]
+    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
+}
+
+function formValidator(entity, validateRules, isSql, additionalParamMap, taskParamMap, contextParameter, subTablePageInfo) {
+  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
+    let validateResult = validator(entity, rules, null, isSql)
+    if (validateResult === true) {
+      if (subRules || totalSubRules) {
+        validateResult = validateSub(entity, subRules, totalSubRules, isSql, dataTypeMap, additionalParamMap, taskParamMap, contextParameter, subTablePageInfo)
+      }
+    }
+    return validateResult
+  } else {
+    // 表示没有子表验证规则
+    return validator(entity, validateRules, null, isSql)
+  }
+}
+
+// 驼峰命名改为下划线命名，例如：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
+}

package/packages/plugins/index.js

@@ -0,0 +1,8 @@
+import formValidatorService from './formValidatorUtil'
+
+export default {
+  install: function(Vue, options) {
+    Vue.prototype.$formValidator = formValidatorService.formValidator
+    Vue.prototype.$getValidator = formValidatorService.getValidator
+  }
+}

package/packages/workflow-editor/index.js

@@ -0,0 +1,14 @@
+import WorkflowEditor from './src/workflow-editor'
+import wfEditorStore from './src/store/workflow-editor'
+import WorkflowHistory from './src/workflow-history'
+
+WorkflowEditor.install = function(Vue) {
+  Vue.component(WorkflowEditor.name, WorkflowEditor)
+  Vue.component(WorkflowHistory.name, WorkflowHistory)
+}
+
+export default {
+  WorkflowEditor,
+  WorkflowHistory,
+  wfEditorStore
+}