workflow-editor 0.9.68-dw → 0.9.68

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

@@ -0,0 +1,392 @@
+<template>
+  <div>
+    <div>
+      <el-row>
+        <el-checkbox-group v-model="actionArr" @change="changeActionArr">
+          <el-col :span="8">
+            <el-checkbox label="add">
+              {{ $t('workflowEditor.condition.rowsCanBeAdded') }}
+              <i v-if="actionArr && actionArr.indexOf('add') !== -1" class="el-icon-s-tools" @click="showButtonVisible('add')" />
+            </el-checkbox>
+          </el-col>
+          <el-col :span="8">
+            <el-checkbox label="delete">
+              {{ $t('workflowEditor.condition.deleteLine') }}
+              <i v-if="actionArr && actionArr.indexOf('delete') !== -1" class="el-icon-s-tools" @click="showButtonVisible('delete')" />
+            </el-checkbox>
+          </el-col>
+          <el-col :span="8">
+            <el-checkbox label="update">
+              {{ $t('workflowEditor.condition.modifiableHistoricalData') }}
+              <i v-if="actionArr && actionArr.indexOf('update') !== -1" class="el-icon-s-tools" @click="showButtonVisible('update')" />
+            </el-checkbox>
+          </el-col>
+        </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> -->
+      </el-row>
+      <selection-conditions v-if="showButtonVisibleFlag" :attribute-map="subtableConditionItem" :condition-list="buttonVisibleCon.condition" :parent-condition="buttonVisibleCon.parentCondition" :user-condition="buttonVisibleCon.userCondition" :is-add="buttonType && buttonType=== 'add'" @close="saveButtonVisible" />
+    </div>
+    <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-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"
+        />
+        <el-table-column
+          type="index"
+          width="50"
+        />
+        <el-table-column
+          prop="name"
+          :label="$t('workflowEditor.task.propertyName')"
+          width="280"
+        >
+          <template slot-scope="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"
+        >
+          <template slot-scope="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')"
+        >
+          <template slot-scope="scope">
+            <i class="el-icon-s-tools" @click="selectCondition(scope.row)" />
+            <!-- <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'
+
+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.$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.$set(this, 'buttonVisibleCon', {})
+      }
+      this.$set(this, 'showButtonVisibleFlag', true)
+    },
+    saveButtonVisible(param) {
+      if (param) {
+        if (!this.actionVisibleConditionArr) {
+          this.actionVisibleConditionArr = {}
+        }
+        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>

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

@@ -0,0 +1,241 @@
+<template>
+  <div>
+    <el-card class="box-card">
+      <span v-for="(mapValue, key) in subtableConditionMap" :key="key">
+        <div slot="header" class="clearfix">
+          <el-row>
+            <el-col :span="12">
+              <span>{{ key }}</span>
+            </el-col>
+            <el-col v-if="selectedFieldMap[key]" :span="12">
+              <el-switch
+                v-model="selectedFieldMap[key].sumPermission"
+                :inactive-text="$t('workflowEditor.condition.accessControl')"
+                @change="changeSumPermission(key)"
+              />
+            </el-col>
+          </el-row>
+          <el-row>
+            <el-col>
+              <span v-if="selectedFieldMap[key] && selectedFieldMap[key].sumPermission">
+                <span style="color: cornflowerblue">{{ $t('workflowEditor.condition.formBindingModel') }}：</span>
+                <span style="padding-left:5px"><el-input v-model="selectedFieldMap[key].modelName" style="width:300px" /></span>
+                <el-button icon="el-icon-refresh" type="text" @click="refreshModelName(key)" />
+              </span>
+            </el-col>
+          </el-row>
+          <!-- <span>{{ selectedFieldMap }}</span> -->
+        </div>
+        <div v-if="selectedFieldMap[key] && selectedFieldMap[key].sumPermission">
+          <editable-child-field-setting :setting="selectedFieldMap[key]" :table-name="key" @combinationParameters="combinationParameters" />
+        </div>
+      </span>
+    </el-card>
+  </div>
+</template>
+
+<script>
+import editableChildFieldSetting from './editable-child-field-setting'
+import componentsConfigUtil from './componentsConfigUtil'
+import { mapGetters } from 'vuex'
+export default {
+  name: 'EditableChildFields',
+  components: {
+    editableChildFieldSetting
+  },
+  props: {
+    value: {
+      type: [Array, Object],
+      default: null
+    }
+  },
+  data() {
+    let selectedFields = []
+    if (this.value !== '' && this.value !== null && this.value !== undefined) {
+      if (Array.isArray(this.value)) {
+        selectedFields = this.value
+      } else {
+        // 只有一个字段时其实是field对象
+        selectedFields.push(this.value)
+      }
+    }
+    return {
+      selectedFields,
+      selectedFieldMap: {}
+    }
+  },
+  computed: {
+    ...mapGetters('wfEditor', [
+      'subtableConditionMap'
+    ])
+  },
+  watch: {
+  },
+  created() {
+    if (this.selectedFields && this.selectedFields.length > 0) {
+      this.selectedFields.forEach(item => {
+        const sss = {}
+        const tableName = item.tableName
+        if (item.action) {
+          if (Array.isArray(item.action)) {
+            if (item.action.length > 0) {
+              const sssActionArr = []
+              const actionVisibleCondition = {}
+              item.action.forEach(item1 => {
+                sssActionArr.push(item1.name)
+                const param = {}
+                if (item1.condition) {
+                  param.condition = this.xmlToData(item1.condition)
+                }
+                param.parentCondition = item1.parentCondition
+                param.userCondition = item1.userCondition
+                actionVisibleCondition[item1.name] = param
+                // actionVisibleCondition[item1.name] = item1.visibleCondition
+              })
+              sss.actionArr = sssActionArr
+              sss.visibleConditionArr = actionVisibleCondition
+            }
+          } else {
+            const sssActionArr = []
+            const actionVisibleCondition = {}
+            sssActionArr.push(item.action.name)
+            const param = {}
+            if (item.action.condition) {
+              param.condition = this.xmlToData(item.action.condition)
+            }
+            param.parentCondition = item.action.parentCondition
+            param.userCondition = item.action.userCondition
+            actionVisibleCondition[item.action.name] = param
+            sss.actionArr = sssActionArr
+            sss.visibleConditionArr = actionVisibleCondition
+          }
+        }
+        if (item.field) {
+          if (Array.isArray(item.field)) {
+            if (item.field.length > 0) {
+              const sssFieldArr = []
+              item.field.forEach(item2 => {
+                const fieldItem = {}
+                fieldItem.name = item2.name
+                fieldItem.constraintRule = item2.constraintRule
+                fieldItem.condition = this.xmlToData(item2.condition)
+                fieldItem.userCondition = item2.userCondition
+                fieldItem.parentCondition = item2.parentCondition
+                sssFieldArr.push(fieldItem)
+              })
+              sss.fieldArr = sssFieldArr
+            }
+          } else {
+            const sssFieldArr = []
+            const fieldItem = {}
+            fieldItem.name = item.field.name
+            fieldItem.constraintRule = item.field.constraintRule
+            fieldItem.condition = this.xmlToData(item.field.condition)
+            fieldItem.userCondition = item.field.userCondition
+            fieldItem.parentCondition = item.field.parentCondition
+            sssFieldArr.push(fieldItem)
+            sss.fieldArr = sssFieldArr
+          }
+        }
+        if (item.modelName) {
+          sss.modelName = item.modelName
+        } else {
+          sss.modelName = null
+        }
+        if (item.permission) {
+          sss.sumPermission = item.permission
+        } else {
+          sss.sumPermission = false
+        }
+        this.$set(this.selectedFieldMap, tableName, sss)
+      })
+    }
+    if (this.subtableConditionMap) {
+      for (var key in this.subtableConditionMap) {
+        if (!this.selectedFieldMap[key]) {
+          const sss = {}
+          sss.tableName = key
+          sss.modelName = this.subtableConditionMap[key].modelName
+          sss.sumPermission = false
+          this.$set(this.selectedFieldMap, key, sss)
+        }
+      }
+    }
+  },
+  mounted() {
+
+  },
+  methods: {
+    ...componentsConfigUtil,
+    combinationParameters(subTableItem) {
+      if (subTableItem && subTableItem.tableName) {
+        if (this.selectedFields && this.selectedFields.length > 0) {
+          const index = this.selectedFields.findIndex((fie) => fie.tableName === subTableItem.tableName)
+          if (index !== -1) {
+            // this.selectedFields[index] = subTableItem
+            this.$set(this.selectedFields, index, subTableItem)
+          } else {
+            this.selectedFields.push(subTableItem)
+          }
+        } else {
+          this.selectedFields = []
+          this.selectedFields.push(subTableItem)
+        }
+        this.$emit('input', this.selectedFields)
+      }
+    },
+    refreshModelName(key) {
+      if (this.subtableConditionMap && this.subtableConditionMap[key] && this.subtableConditionMap[key].modelName) {
+        if (this.selectedFieldMap[key]) {
+          const sss = this.selectedFieldMap[key]
+          sss.modelName = this.subtableConditionMap[key].modelName
+        } else {
+          const sss = {}
+          sss.modelName = this.subtableConditionMap[key].modelName
+          this.$set(this.selectedFieldMap, key, sss)
+        }
+        this.$message({
+          showClose: true,
+          type: 'success',
+          message: this.$t('workflowEditorMessage.updateSuccessful')
+        })
+      }
+    },
+    changeSumPermission(key) {
+      if (key && this.selectedFieldMap[key]) {
+        if (!this.selectedFields) {
+          this.$set(this, 'selectedFields', [])
+        }
+        if (this.selectedFieldMap[key].sumPermission === false) {
+          const index = this.selectedFields.findIndex((fie) => fie.tableName === key)
+          if (index !== null && index !== undefined && index !== -1) {
+            // this.$delete(this.selectedFields, index)
+            this.$set(this.selectedFields[index], 'permission', false)
+          } else {
+            this.$set(this.selectedFields, this.selectedFields.length, {
+              permission: false,
+              tableName: key
+            })
+          }
+        } else {
+          const index = this.selectedFields.findIndex((fie) => fie.tableName === key)
+          if (index !== null && index !== undefined && index !== -1) {
+            // this.$delete(this.selectedFields, index)
+            this.$set(this.selectedFields[index], 'permission', true)
+          } else {
+            this.$set(this.selectedFields, this.selectedFields.length, {
+              permission: true,
+              tableName: key
+            })
+          }
+        }
+      }
+      this.$emit('input', this.selectedFields)
+    }
+  }
+}
+</script>
+
+<style lang="scss" scoped>
+
+</style>