workflow-editor 0.0.81-up-tmp11 → 0.0.81-up-tmp15

package/packages/plugins/formValidatorUtil.js

@@ -1,723 +0,0 @@
-import Validator from 'async-validator'
-import { getI18n } from '../workflow-editor/src/util'
-import { parseSubTablePermissionCondition } from 'agilebuilder-ui'
-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) {
-  return validatorEntity(entity, validateRules, rowIndex, true, isSql, pageNum, pageRowIndex, isNeedField)
-}
-/**
- *
- * @param {*} entity
- * @param {*} validateRules
- * @param {*} rowIndex
- * @param {*} isShouldRepeateValdate 是否需要再次验证大写字段名
- * @returns
- */
-function validatorEntity(entity, validateRules, rowIndex, isShouldRepeateValdate, isSql, pageNum, pageRowIndex, isNeedField) {
-  let result = false
-  const validator = new Validator(validateRules)
-  let fieldName
-  validator.validate(
-    entity,
-    {
-      first: true
-    },
-    (errors, fields) => {
-      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)
-        }
-      }
-    }
-  )
-  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
-) {
-  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]
-        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)
-        if ((!isNeedField && validateResult !== true) || (isNeedField && validateResult.msg !== true)) {
-          // 表示验证失败，无需继续验证
-          if(isNeedField){
-            validateResult.listCode = prop
-          }
-          return validateResult
-        }
-      }
-    }
-  }
-
-  for (const subTableName in copyTotalSubRules) {
-    const validateResult = validateTotalSubTable(copyTotalSubRules, entity, subTableName)
-    if (validateResult !== true) {
-      if(isNeedField){
-        return {msg: validateResult, listCode: subTableName}
-      } else {
-        return validateResult
-      }
-    }
-  }
-  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
-) {
-  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, 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
-        )
-      }
-    }
-    return validateResult
-  } else {
-    // 表示没有子表验证规则
-    return validator(entity, validateRules, null, isSql, null, null, isNeedField)
-  }
-}
-
-// 驼峰命名改为下划线命名，例如：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
-}