workflow-editor 0.0.7-up → 0.0.8-up

package/packages/workflow-editor/src/properties-editors/human-task/componentsConfigUtil.js

@@ -1,291 +0,0 @@
-// import modulePageService from '@/subsystems/mms/api/module-page'
-import { getI18n } from '../../../../workflow-editor/src/util'
-const utiljs = {
-  // 格式化json
-  xmlToData(xmlData) {
-    const tableData = []
-    if (xmlData) {
-      const arr = xmlData.split(' ')
-      if (arr && arr.length > 0) {
-        let num = 1
-        let leftBracket = ''
-        let propName = ''
-        let operator = ''
-        let propValue = ''
-        let rightBracket = ''
-        let logicOperator = ''
-        let propValueType = null
-        for (var i = 0; i < arr.length; i++) {
-          var str = arr[i]
-          if (str.indexOf('(') !== -1) {
-            if (this.operationArr) {
-              this.operationArr.push([])
-            }
-            leftBracket = ''
-            propName = ''
-            operator = ''
-            propValue = ''
-            rightBracket = ''
-            logicOperator = ''
-            const leftarr = str.split('${field[')
-            leftBracket = leftarr[0]
-            propName = leftarr[1].replace(']}', '')
-            if (this.operationArr) {
-              const operatorsArr = this.getOperators(this.fieldMap[propName])
-              this.operationArr[num - 1] = operatorsArr
-            }
-            continue
-          }
-          if (str.indexOf('(') === -1 && str.indexOf('${field[') !== -1) {
-            if (this.operationArr) {
-              this.operationArr.push([])
-            }
-            leftBracket = ''
-            propName = ''
-            operator = ''
-            propValue = ''
-            rightBracket = ''
-            logicOperator = ''
-            propName = str.replace('${field[', '').replace(']}', '')
-            if (this.operationArr) {
-              const operatorsArr = this.getOperators(this.fieldMap[propName])
-              this.operationArr[num - 1] = operatorsArr
-            }
-            continue
-          }
-          if (str.indexOf('operator.') !== -1 && str.indexOf('condition.') === -1) {
-            operator = str
-            continue
-          }
-          if (operator !== '' && propValue === '') {
-            if (str.indexOf(')') !== -1) {
-              if (str.indexOf(')))') !== -1) {
-                propValue = str.replace(')))', '')
-                rightBracket = ')))'
-              } else if (str.indexOf('))') !== -1) {
-                propValue = str.replace('))', '')
-                rightBracket = '))'
-              } else if (str.indexOf(')') !== -1) {
-                propValue = str.replace(')', '')
-                rightBracket = ')'
-              }
-            } else {
-              propValue = str
-            }
-            if (propValue && propValue !== '') {
-              if (propValue.indexOf('${task.') !== -1) {
-                propValueType = 'task'
-              } else if (propValue.indexOf('${context.') !== -1) {
-                propValueType = 'context'
-              } else if (propValue.indexOf('${obj.') !== -1) {
-                propValueType = 'obj'
-              } else if (propValue.indexOf('${subObj.') !== -1) {
-                propValueType = 'subObj'
-              } else if (propValue.indexOf('${request.') !== -1) {
-                propValueType = 'request'
-              } else if (propValue.indexOf('${input.') !== -1) {
-                propValueType = 'input'
-              } else if (propValue.indexOf('${custom.') !== -1) {
-                propValueType = 'custom'
-              }
-            }
-            continue
-          }
-          if (str.indexOf('condition.') !== -1) {
-            logicOperator = str
-            tableData.push({
-              id: num,
-              leftBracket: leftBracket,
-              propName: propName,
-              operator: operator,
-              propValue: propValue,
-              rightBracket: rightBracket,
-              logicOperator: logicOperator,
-              propValueType: propValueType
-            })
-            num += 1
-          } else if (propValue && propValue !== '') {
-            if (!logicOperator || logicOperator === '') {
-              logicOperator = 'condition.operator.or'
-              tableData.push({
-                id: num,
-                leftBracket: leftBracket,
-                propName: propName,
-                operator: operator,
-                propValue: propValue,
-                rightBracket: rightBracket,
-                logicOperator: logicOperator,
-                propValueType: propValueType
-              })
-              num += 1
-            }
-          }
-        }
-      }
-    }
-    return tableData
-  },
-  getOperatorsArr(conditionList) {
-    if (conditionList && conditionList.length > 0) {
-      for (var i = 0; i < conditionList.length; i++) {
-        this.operationArr.push([])
-        const item = conditionList[i]
-        const operatorsArr = this.getOperators(this.fieldMap[item.propName])
-        this.operationArr[i] = operatorsArr
-      }
-    }
-  },
-  getRetunrOperatorsArr(conditionList, fieldMap) {
-    const operationArr = []
-    if (conditionList && conditionList.length > 0) {
-      for (var i = 0; i < conditionList.length; i++) {
-        operationArr.push([])
-        const item = conditionList[i]
-        const operatorsArr = this.getOperators(fieldMap[item.propName])
-        operationArr[i] = operatorsArr
-      }
-    }
-    return operationArr
-  },
-  dataToXml(tableData) {
-    let stringData = ''
-    if (tableData && tableData.length > 0) {
-      for (var i = 0; i < tableData.length; i++) {
-        var item = tableData[i]
-        let logicOperator = logicOperator = item.logicOperator
-        if (i === tableData.length - 1) {
-          logicOperator = ''
-        }
-
-        stringData = stringData + item.leftBracket + '${field[' + item.propName + ']} ' + item.operator + ' ' + item.propValue + item.rightBracket + ' ' + logicOperator + ' '
-      }
-    }
-    return stringData
-  },
-  formatConditionList(conditionList) {
-    let returnStr = ''
-    if (conditionList) {
-      if (typeof (conditionList) === 'string') {
-        // 先进行转换再解析
-        const dataList = this.xmlToData(conditionList)
-        returnStr = this.formatConditionListTwo(dataList)
-      } else {
-        returnStr = this.formatConditionListTwo(conditionList)
-      }
-    }
-    if (returnStr && returnStr !== '') {
-      const endStr = returnStr.substring(returnStr.length - 1)
-      if (endStr === '者' || endStr === '且') {
-        returnStr = returnStr.substring(0, returnStr.length - 2)
-      }
-    }
-    return returnStr
-  },
-  formatConditionListTwo(conditionList) {
-    let returnStr = ''
-    if (conditionList && conditionList.length > 0) {
-      for (var i = 0; i < conditionList.length; i++) {
-        const item = conditionList[i]
-        if (item && item.propName) {
-          const operatorsArr = this.getOperators(this.fieldMap[item.propName])
-          if (operatorsArr && operatorsArr.length > 0) {
-            const operator = operatorsArr.filter(operItem => {
-              return operItem.name === item.operator
-            })
-            returnStr += item.leftBracket
-            if (this.fieldMap[item.propName] && this.fieldMap[item.propName].label) {
-              returnStr += this.fieldMap[item.propName].label + ' '
-            }
-
-            if (operator && operator.length > 0) {
-              returnStr += operator[0].label + ' '
-            }
-            returnStr += item.propValue + item.rightBracket + ' '
-            if (item.logicOperator) {
-              if (item.logicOperator === 'or') {
-                returnStr += '或者'
-              } else {
-                returnStr += '并且'
-              }
-            }
-          }
-        }
-      }
-    }
-    return returnStr
-  },
-  // 实时根据类型改变连接符
-  getOperators(item) {
-    if (item) {
-      if (item.type === 'INTEGER' || item.type === 'LONG' || item.type === 'DOUBLE' || item.type === 'FLOAT') {
-        return [{
-          name: 'operator.number.gt',
-          label: getI18n().t('workflowEditor.process.greaterThan')
-        }, {
-          name: 'operator.number.lt',
-          label: getI18n().t('workflowEditor.process.lessThan')
-        }, {
-          name: 'operator.number.eq',
-          label: getI18n().t('workflowEditor.process.beEqualTo')
-        }, {
-          name: 'operator.number.le',
-          label: getI18n().t('workflowEditor.process.notGreaterThan')
-        }, {
-          name: 'operator.number.ge',
-          label: getI18n().t('workflowEditor.process.notLessThan')
-        }, {
-          name: 'operator.number.ne',
-          label: getI18n().t('workflowEditor.process.notEqualTo')
-        }]
-      } else if (item.type === 'DATE' || item.type === 'TIME') {
-        return [{
-          name: 'operator.date.gt',
-          label: getI18n().t('workflowEditor.process.laterThan')
-        }, {
-          name: 'operator.date.lt',
-          label: getI18n().t('workflowEditor.process.earlierThan')
-        }, {
-          name: 'operator.date.eq',
-          label: getI18n().t('workflowEditor.process.beEqualTo')
-        }, {
-          name: 'operator.date.le',
-          label: getI18n().t('workflowEditor.process.noLaterThan')
-        }, {
-          name: 'operator.date.ge',
-          label: getI18n().t('workflowEditor.process.noEarlierThan')
-        }]
-      } else if (item.type === 'TEXT') {
-        return [{
-          name: 'operator.text.eq',
-          label: getI18n().t('workflowEditor.process.beEqualTo')
-        }, {
-          name: 'operator.text.neq',
-          label: getI18n().t('workflowEditor.process.notEqualTo')
-        }, {
-          name: 'operator.text.contain',
-          label: getI18n().t('workflowEditor.process.contain')
-        }, {
-          name: 'operator.text.contain.not',
-          label: getI18n().t('workflowEditor.process.notIncluded')
-        }]
-      } else {
-        return [{
-          name: 'operator.text.eq',
-          label: getI18n().t('workflowEditor.process.beEqualTo')
-        }, {
-          name: 'operator.text.neq',
-          label: getI18n().t('workflowEditor.process.notEqualTo')
-        }]
-      }
-    } else {
-      return [{
-        name: 'operator.text.eq',
-        label: getI18n().t('workflowEditor.process.beEqualTo')
-      }, {
-        name: 'operator.text.neq',
-        label: getI18n().t('workflowEditor.process.notEqualTo')
-      }]
-    }
-  }
-}
-export default utiljs

package/packages/workflow-editor/src/properties-editors/human-task/custom-actions.vue

@@ -1,249 +0,0 @@
-<template>
-  <div>
-    <el-row>
-      <el-button type="primary" size="mini" plain icon="el-icon-circle-plus-outline" @click="add">
-        {{ $t('workflowEditorPublicModel.add') }}
-      </el-button>
-      <el-button type="primary" size="mini" plain icon="el-icon-delete" @click="remove">
-        {{ $t('workflowEditorPublicModel.delete') }}
-      </el-button>
-      <el-table
-        ref="table"
-        :data="actions"
-        row-key="type"
-        border
-        highlight-current-row
-        style="width: 100%"
-        @current-change="handleCurrentChange"
-      >
-        <el-table-column
-          type="index"
-        />
-        <el-table-column
-          :label="$t('workflowEditor.task.operationType')"
-          width="180"
-        >
-          <template slot-scope="scope">
-            <el-select v-model="scope.row.type" @change="isDuplicated">
-              <el-option
-                v-for="item in actionTypes"
-                :key="item.id"
-                :value="item.type"
-                :label="item.label"
-              />
-            </el-select>
-          </template>
-        </el-table-column>
-        <el-table-column
-          prop="label"
-          :label="$t('workflowEditor.task.name')"
-          width="180"
-        >
-          <template slot-scope="scope">
-            <el-input v-model="scope.row.label" />
-          </template>
-        </el-table-column>
-        <el-table-column
-          prop="visible"
-          :label="$t('workflowEditor.task.visibleOrNot')"
-        >
-          <template slot-scope="scope">
-            <el-checkbox v-model="scope.row.visible" />
-          </template>
-        </el-table-column>
-        <el-table-column
-          prop="condition"
-          :label="$t('workflowEditor.task.condition')"
-        >
-          <template slot-scope="scope">
-            <el-input
-              :value="formatCondition(scope.row.condition)"
-              type="textarea"
-              autosize
-              @focus="selectCondition(scope.row)"
-            />
-          </template>
-        </el-table-column>
-      </el-table>
-    </el-row>
-    <additional-condition-dialog v-if="showAdditionalCondition" v-model="currentRow.condition" @close="showAdditionalCondition=false" />
-  </div>
-</template>
-<script>
-import { getI18n } from '../../../../workflow-editor/src/util'
-import AdditionalConditionDialog from './additional-condition-dialog'
-import { parseCondition, displayCondition } from '../common/additional-condition-utils'
-export default {
-  name: 'CustomActions',
-  components: {
-    AdditionalConditionDialog
-  },
-  props: {
-    value: {
-      type: Object,
-      default: null
-    }
-  },
-  data() {
-    const actions = []
-    let count = 1
-    if (this.value.action) {
-      if (Array.isArray(this.value.action)) {
-        for (const action of this.value.action) {
-          actions.push({
-            ...action,
-            id: count
-          })
-          count++
-        }
-      } else {
-        actions.push({
-          ...this.value.action,
-          id: count
-        })
-        count++
-      }
-    }
-    return {
-      actions,
-      actionTypes: [{
-        type: 'SAVE',
-        label: getI18n().t('workflowEditor.task.save')
-      }, {
-        type: 'SUBMIT',
-        label: getI18n().t('workflowEditor.task.submission')
-      }, {
-        type: 'APPROVE',
-        label: getI18n().t('workflowEditor.task.agree')
-      }, {
-        type: 'REFUSE',
-        label: getI18n().t('workflowEditor.task.disagree')
-      }, {
-        type: 'AGREEMENT',
-        label: getI18n().t('workflowEditor.task.favor')
-      }, {
-        type: 'OPPOSE',
-        label: getI18n().t('workflowEditor.task.opposition')
-      }, {
-        type: 'KIKEN',
-        label: getI18n().t('workflowEditor.task.waiver')
-      }, {
-        type: 'DRAW',
-        label: getI18n().t('workflowEditor.task.receive')
-      }, {
-        type: 'ABANDON_DRAW',
-        label: getI18n().t('workflowEditor.task.giveUp')
-      }, {
-        type: 'ADD_SIGN',
-        label: getI18n().t('workflowEditor.task.additionalSignature')
-      }, {
-        type: 'REMOVE_SIGN',
-        label: getI18n().t('workflowEditor.task.reductionOfSignature')
-      }, {
-        type: 'ASSIGN_TASK',
-        label: getI18n().t('workflowEditor.task.assignTask')
-      }, {
-        type: 'COPY',
-        label: getI18n().t('workflowEditor.task.copyTask')
-      }, {
-        type: 'GET_BACK_BUTTON',
-        label: getI18n().t('workflowEditor.task.retrieveTask')
-      }, {
-        type: 'READED',
-        label: getI18n().t('workflowEditor.task.readTask')
-      }, {
-        type: 'EXPORT_REPORT',
-        label: getI18n().t('workflowEditor.task.exportReport')
-      }],
-      currentRow: null,
-      count,
-      showAdditionalCondition: false
-    }
-  },
-  mounted() {
-    if (this.actions.length > 0) {
-      this.selectRow(this.actions[this.actions.length - 1])
-    }
-    this.$watch('actions', function(newVal, oldVal) {
-      const actions = []
-      for (const action of this.actions) {
-        const row = {
-          ...action
-        }
-        delete row['id']
-        actions.push(row)
-      }
-      this.$emit('input', { action: actions })
-    }, {
-      deep: true
-    })
-  },
-  methods: {
-    selectRow(row) {
-      this.$refs.table.setCurrentRow(row)
-    },
-    getRowIndex(row) {
-      for (let i = 0; i < this.actions.length; i++) {
-        if (this.actions[i].id === row.id) {
-          return i
-        }
-      }
-      return -1
-    },
-    handleCurrentChange(val) {
-      this.currentRow = val
-    },
-    isDuplicated(val) {
-      const index = this.getRowIndex(this.currentRow)
-      console.log('index:' + index)
-      for (let i = 0; i < this.actions.length; i++) {
-        if (i === index) continue
-        if (this.actions[i].type === val) {
-          this.$alert(this.$t('workflowEditorMessage.duplicateOperationTypeWithLinePleaseReselect', { row: (i + 1) }))
-          this.currentRow.type = ''
-        }
-      }
-    },
-    add() {
-      for (let i = 0; i < this.actions.length; i++) {
-        const action = this.actions[i]
-        if (action.type === '' || action.label === '') {
-          this.$alert(this.$t('workflowEditorMessage.theOperationTypeOrNameInLineIsEmpty', { row: (i + 1) }))
-          return
-        }
-      }
-      const newRow = {
-        id: this.count,
-        type: '',
-        label: '',
-        visible: true,
-        condition: ''
-      }
-      this.actions.push(newRow)
-      this.selectRow(newRow)
-      this.count++
-    },
-    remove() {
-      let index = this.getRowIndex(this.currentRow)
-      this.actions.splice(index, 1)
-      if (this.actions.length > 0) {
-        index = (index <= (this.actions.length - 1) ? index : (this.actions.length - 1))
-        this.$refs.table.setCurrentRow(this.actions[index])
-      }
-    },
-    formatCondition(value) {
-      if (value === '' || !value) return this.$t('workflowEditor.task.nothing')
-      const conditions = []
-      parseCondition(conditions, value)
-      return displayCondition(conditions)
-    },
-    selectCondition(row) {
-      this.selectRow(row)
-      if (!this.currentRow) {
-        this.$set(this.currentRow, 'condition', '')
-      }
-      this.showAdditionalCondition = true
-    }
-  }
-}
-</script>