workflow-editor 0.0.81-up-tmp8 → 0.0.81-up-tmp10

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

@@ -0,0 +1,256 @@
+<template>
+  <div>
+    <el-row>
+      <el-button type="primary" size="small" plain :icon="CirclePlus" @click="add">
+        {{ $t('workflowEditorPublicModel.add') }}
+      </el-button>
+      <el-button type="primary" size="small" plain :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 v-slot="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 v-slot="scope">
+            <el-input v-model="scope.row.label" />
+          </template>
+        </el-table-column>
+        <el-table-column
+          prop="visible"
+          :label="$t('workflowEditor.task.visibleOrNot')"
+        >
+          <template v-slot="scope">
+            <el-checkbox v-model="scope.row.visible" />
+          </template>
+        </el-table-column>
+        <el-table-column
+          prop="condition"
+          :label="$t('workflowEditor.task.condition')"
+        >
+          <template v-slot="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 setup>
+import {
+  CirclePlus,
+  Delete
+} from '@element-plus/icons-vue'
+</script>
+<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: {
+    model: {
+      type: Object,
+      default: null
+    }
+  },
+  data() {
+    const actions = []
+    let count = 1
+    if (this.model.action) {
+      if (Array.isArray(this.model.action)) {
+        for (const action of this.model.action) {
+          actions.push({
+            ...action,
+            id: count
+          })
+          count++
+        }
+      } else {
+        actions.push({
+          ...this.model.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('updateAction', 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.currentRow.condition = ''
+        // this.$set(this.currentRow, 'condition', '')
+      }
+      this.showAdditionalCondition = true
+    }
+  }
+}
+</script>

package/packages/workflow-editor/src/properties-editors/human-task/editable-child-field-setting.vue

@@ -0,0 +1,405 @@
+<template>
+  <div>
+    <div>
+      <el-checkbox-group v-model="actionArr" @change="changeActionArr">
+        <el-row>
+          <el-col :span="6">
+            <el-checkbox label="notEmpty">
+              {{ $t('workflowEditor.condition.tableDataNotEmpty') }}
+              <el-icon v-if="actionArr && actionArr.indexOf('notEmpty') !== -1" @click="showButtonVisible('notEmpty')"
+                ><Tools
+              /></el-icon>
+            </el-checkbox>
+          </el-col>
+          <el-col :span="6">
+            <el-checkbox label="add">
+              {{ $t('workflowEditor.condition.rowsCanBeAdded') }}
+              <el-icon v-if="actionArr && actionArr.indexOf('add') !== -1" @click="showButtonVisible('add')"
+                ><Tools
+              /></el-icon>
+            </el-checkbox>
+          </el-col>
+          <el-col :span="6">
+            <el-checkbox label="delete">
+              {{ $t('workflowEditor.condition.deleteLine') }}
+              <el-icon v-if="actionArr && actionArr.indexOf('delete') !== -1" @click="showButtonVisible('delete')"
+                ><Tools
+              /></el-icon>
+            </el-checkbox>
+          </el-col>
+          <el-col :span="6">
+            <el-checkbox label="update">
+              {{ $t('workflowEditor.condition.modifiableHistoricalData') }}
+              <el-icon v-if="actionArr && actionArr.indexOf('update') !== -1" @click="showButtonVisible('update')"
+                ><Tools
+              /></el-icon>
+            </el-checkbox>
+          </el-col>
+        </el-row>
+      </el-checkbox-group>
+      <!-- <el-col :span="4">
+          <el-radio v-model="permission" label="fieldControl" @change="combinationParameters()">
+            {{ $t('workflowEditor.condition.controlByField') }}
+          </el-radio>
+        </el-col>
+        <el-col :span="4">
+          <el-radio v-model="permission" label="allForbidden" @change="combinationParameters()">
+            {{ $t('workflowEditor.condition.allReadOnly') }}
+          </el-radio>
+        </el-col>
+        <el-col :span="4">
+          <el-radio v-model="permission" label="allRequired" @change="combinationParameters()">
+            {{ $t('workflowEditor.condition.allRequired') }}
+          </el-radio>
+        </el-col> -->
+      <selection-conditions
+        v-if="showButtonVisibleFlag"
+        :attribute-map="subtableConditionItem"
+        :condition-list="buttonVisibleCon.condition"
+        :parent-condition="buttonVisibleCon.parentCondition"
+        :user-condition="buttonVisibleCon.userCondition"
+        :button-type="buttonType"
+        @close="saveButtonVisible"
+      />
+    </div>
+    <div>
+      <el-row>
+        <el-button type="primary" size="small" plain icon="CirclePlus" @click="add">
+          {{ $t('workflowEditorPublicModel.add') }}
+        </el-button>
+        <el-button type="primary" size="small" plain icon="Delete" @click="remove">
+          {{ $t('workflowEditorPublicModel.delete') }}
+        </el-button>
+      </el-row>
+      <el-table
+        ref="table"
+        :data="fieldArr"
+        border
+        highlight-current-row
+        style="width: 100%"
+        @selection-change="handleSelectionChange"
+        @current-change="handleCurrentChange"
+      >
+        <el-table-column type="selection" width="55" align="center" />
+        <el-table-column type="index" width="50" align="center" />
+        <el-table-column prop="name" :label="$t('workflowEditor.task.propertyName')" width="280" align="center">
+          <template v-slot="scope">
+            <el-select v-model="scope.row.name" size="small" filterable @change="combinationParameters">
+              <el-option :label="$t('workflowEditor.condition.allFields')" value="all_fields" />
+              <el-option v-for="item in attributeArr" :key="item.value" :label="item.label" :value="item.value" />
+            </el-select>
+          </template>
+        </el-table-column>
+        <el-table-column
+          prop="constraintRule"
+          :label="$t('workflowEditor.task.editingMethod')"
+          width="380"
+          align="center"
+        >
+          <template v-slot="scope">
+            <el-radio-group v-model="scope.row.constraintRule" @change="combinationParameters">
+              <el-radio label="REQUIRED">
+                {{ $t('workflowEditorMessage.mustFill') }}
+              </el-radio>
+              <el-radio label="READ_ONLY">
+                {{ $t('workflowEditorMessage.readOnly') }}
+              </el-radio>
+            </el-radio-group>
+          </template>
+        </el-table-column>
+        <el-table-column prop="condition" :label="$t('workflowEditor.task.condition')" align="center">
+          <template v-slot="scope">
+            <el-icon @click="selectCondition(scope.row)"><Tools /></el-icon>
+            <!-- <el-input
+              :value="formatConditionList(scope.row.condition)"
+              type="textarea"
+              autosize
+              @focus="selectCondition(scope.row)"
+            /> -->
+          </template>
+        </el-table-column>
+      </el-table>
+      <selection-conditions
+        v-if="showAdditionalCondition"
+        :attribute-map="subtableConditionItem"
+        :condition-list="currentRow.condition"
+        :parent-condition="currentRow.parentCondition"
+        :user-condition="currentRow.userCondition"
+        @close="savebuttonSetting"
+      />
+    </div>
+  </div>
+</template>
+
+<script>
+import { mapGetters } from 'vuex'
+import selectionConditions from './selection-conditions'
+import componentsConfigUtil from './componentsConfigUtil'
+import { CirclePlus, Delete } from '@element-plus/icons-vue'
+
+export default {
+  name: 'EditableChildFieldSetting',
+  components: {
+    selectionConditions
+  },
+  props: {
+    setting: {
+      type: Object,
+      default: null
+    },
+    tableName: {
+      type: String,
+      default: null
+    }
+  },
+  data() {
+    let actionArr = []
+    if (this.setting && this.setting.actionArr) {
+      actionArr = this.setting.actionArr
+    }
+    let fieldArr = []
+    if (this.setting && this.setting.fieldArr) {
+      fieldArr = this.setting.fieldArr
+    }
+    let actionVisibleConditionArr
+    if (this.setting && this.setting.visibleConditionArr) {
+      actionVisibleConditionArr = this.setting.visibleConditionArr
+    }
+    let modelName
+    if (this.setting && this.setting.modelName) {
+      modelName = this.setting.modelName
+    }
+    let sumPermission
+    if (this.setting && this.setting.sumPermission !== null) {
+      sumPermission = this.setting.sumPermission
+    }
+    return {
+      sumPermission,
+      subtableConditionItem: null,
+      attributeArr: null,
+      showAdditionalCondition: false,
+      currentRow: null,
+      multipleSelection: null,
+      actionArr,
+      fieldArr,
+      queryList: null,
+      fieldMap: null,
+      fieldNameMap: null,
+      actionVisibleConditionArr,
+      buttonType: null,
+      buttonVisibleCon: null,
+      showButtonVisibleFlag: false,
+      clickButton: false,
+      operationArr: [],
+      modelName
+    }
+  },
+  watch: {
+    setting: {
+      handler(newValue, oldValue) {
+        if (newValue && newValue.actionArr) {
+          this.actionArr = newValue.actionArr
+        }
+        if (newValue && newValue.fieldArr) {
+          this.fieldArr = newValue.fieldArr
+        }
+        if (newValue && newValue.actionVisibleConditionArr) {
+          this.actionVisibleConditionArr = newValue.actionVisibleConditionArr
+        }
+        this.modelName = newValue.modelName
+        this.sumPermission = newValue.sumPermission
+        this.combinationParameters()
+      },
+      deep: true
+    }
+    // permission: {
+    //   handler(newValue, oldValue) {
+    //     console.log(11111111111111)
+    //     this.combinationParameters()
+    //   }
+    // },
+    // actionArr: {
+    //   handler(newValue, oldValue) {
+    //     console.log(22222222222222)
+    //     this.combinationParameters()
+    //   }
+    // },
+    // fieldArr: {
+    //   handler(newValue, oldValue) {
+    //     console.log(333333333333333)
+    //     this.combinationParameters()
+    //   },
+    //   deep: true
+    // },
+    // actionVisibleConditionArr: {
+    //   handler(newValue, oldValue) {
+    //     console.log(4444444444444444)
+    //     this.combinationParameters()
+    //   },
+    //   deep: true
+    // }
+  },
+  computed: {
+    ...mapGetters('wfEditor', ['subtableConditionMap'])
+  },
+  created() {
+    if (this.subtableConditionMap) {
+      if (this.tableName) {
+        this.subtableConditionItem = this.subtableConditionMap[this.tableName]
+        this.getAttributeArr()
+      }
+    }
+  },
+  mounted() {
+    if (this.subtableConditionMap) {
+      if (this.tableName) {
+        this.subtableConditionItem = this.subtableConditionMap[this.tableName]
+        if (this.subtableConditionMap[this.tableName]) {
+          this.attributeArr = this.subtableConditionItem.attributeArr
+        }
+      }
+    }
+  },
+  methods: {
+    ...componentsConfigUtil,
+    getAttributeArr() {
+      if (this.subtableConditionItem && this.subtableConditionItem.attributeArr) {
+        this.queryList = this.subtableConditionItem.attributeArr
+        this.fieldMap = this.subtableConditionItem.fieldMap
+        this.fieldNameMap = this.subtableConditionItem.fieldNameMap
+      }
+    },
+    savebuttonSetting(param) {
+      if (param) {
+        this.currentRow.condition = param.condition
+        this.currentRow.userCondition = param.userCondition
+        this.currentRow.parentCondition = param.parentCondition
+        // this.$set(this.currentRow, 'condition', param.condition)
+        // this.$set(this.currentRow, 'userCondition', param.userCondition)
+        // this.$set(this.currentRow, 'parentCondition', param.parentCondition)
+        this.combinationParameters()
+      }
+      this.showAdditionalCondition = false
+    },
+    handleCurrentChange(val) {
+      this.currentRow = val
+    },
+    handleSelectionChange(val) {
+      this.multipleSelection = val
+    },
+    selectRow(row) {
+      this.$refs.table.setCurrentRow(row)
+    },
+    add() {
+      if (!this.fieldArr) {
+        this.fieldArr = []
+      }
+      this.fieldArr.push({
+        name: null,
+        constraintRule: null,
+        condition: null
+      })
+      this.combinationParameters()
+    },
+    getCurrentRowIndex() {
+      let index = -1
+      for (let i = 0; i < this.fieldArr.length; i++) {
+        if (this.fieldArr[i].name === this.currentRow.name) {
+          index = i
+          break
+        }
+      }
+      return index
+    },
+    remove() {
+      if (this.multipleSelection && this.multipleSelection.length > 0) {
+        for (var i = 0; i < this.multipleSelection.length; i++) {
+          const selectRow = this.multipleSelection[i]
+          this.selectRow(selectRow)
+          const index = this.getCurrentRowIndex()
+          this.fieldArr.splice(index, 1)
+        }
+        // this.$emit('input', this.selectedFields)
+        this.combinationParameters()
+      }
+    },
+    selectCondition(row) {
+      this.selectRow(row)
+      this.showAdditionalCondition = true
+    },
+    showButtonVisible(type) {
+      this.clickButton = true
+      this.buttonType = type
+      if (this.actionVisibleConditionArr && this.actionVisibleConditionArr[type]) {
+        this.buttonVisibleCon = this.actionVisibleConditionArr[type]
+        // this.$set(this, 'buttonVisibleCon', this.actionVisibleConditionArr[type])
+      } else {
+        this.buttonVisibleCon = {}
+        // this.$set(this, 'buttonVisibleCon', {})
+      }
+      this.showButtonVisibleFlag = true
+      // this.$set(this, 'showButtonVisibleFlag', true)
+    },
+    saveButtonVisible(param) {
+      if (param) {
+        if (!this.actionVisibleConditionArr) {
+          this.actionVisibleConditionArr = {}
+        }
+        this.actionVisibleConditionArr[this.buttonType] = param
+        // this.$set(this.actionVisibleConditionArr, this.buttonType, param)
+        this.combinationParameters()
+      }
+      this.showButtonVisibleFlag = false
+    },
+    changeActionArr() {
+      if (this.clickButton) {
+        this.actionArr.push(this.buttonType)
+        this.clickButton = false
+      } else {
+        this.combinationParameters()
+      }
+    },
+    // 组合参数
+    combinationParameters() {
+      const subTableItem = {}
+      subTableItem.modelName = this.modelName
+      subTableItem.tableName = this.tableName
+      subTableItem.permission = this.sumPermission
+      const actions = []
+      if (this.actionArr && this.actionArr.length > 0) {
+        this.actionArr.forEach((type) => {
+          const action = {}
+          action.name = type
+          if (this.actionVisibleConditionArr && this.actionVisibleConditionArr[type]) {
+            const param = this.actionVisibleConditionArr[type]
+            action.condition = this.dataToXml(param.condition)
+            action.parentCondition = param.parentCondition
+            action.userCondition = param.userCondition
+          }
+          actions.push(action)
+        })
+        subTableItem.action = actions
+      }
+      if (this.fieldArr && this.fieldArr.length > 0) {
+        const field = []
+        this.fieldArr.forEach((item) => {
+          const fieldItem = {}
+          fieldItem.name = item.name
+          fieldItem.constraintRule = item.constraintRule
+          if (item.condition) {
+            fieldItem.condition = this.dataToXml(item.condition)
+          }
+          fieldItem.userCondition = item.userCondition
+          fieldItem.parentCondition = item.parentCondition
+          field.push(fieldItem)
+        })
+        subTableItem.field = field
+      }
+      console.log('触发combinationParameters', subTableItem)
+      this.$emit('combinationParameters', subTableItem)
+    }
+  }
+}
+</script>
+
+<style lang="scss" scoped></style>