workflow-editor 0.9.68-dw → 0.9.68

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

@@ -0,0 +1,291 @@
+// 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

@@ -0,0 +1,249 @@
+<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>