workflow-editor 0.9.65 → 0.9.66

package/packages/workflow-editor/src/properties-editors/common/reminder.vue

@@ -0,0 +1,179 @@
+<template>
+  <el-form :model="model" label-width="80px">
+    <el-form-item :label="$t('workflowEditor.task.needToBeUrged')">
+      <el-switch
+        v-model="showReminder"
+      />
+    </el-form-item>
+    <div v-if="showReminder">
+      <common-notice-tool v-model="model.remindType" :label="$t('workflowEditor.task.urgingMethod')" />
+      <el-form-item v-if="model.remindType && model.remindType.length > 0 && model.remindType.indexOf('mail') !== -1" :label="$t('workflowEditor.task.selectMailTemplate')">
+        <select-mail-templates v-model="model.noticeMailTemplateCode" @set-value="setMailTemplateCode" />
+      </el-form-item>
+      <el-form-item :label="$t('workflowEditor.task.timeLimitForHandling')" size="mini">
+        <el-input-number v-model="model.dueDate" controls-position="right" :min="1" :max="30" style="width:90px" />
+        <el-select v-model="model.dueTimeUnit" style="width:70px">
+          <el-option :label="$t('workflowEditor.task.day')" value="day" />
+          <el-option :label="$t('workflowEditor.task.hour')" value="hour" />
+        </el-select>
+        <span>{{ $t('workflowEditor.task.urgingInterval') }}</span><el-input-number v-model="model.repeat" controls-position="right" :min="1" :max="30" style="width:90px" />
+        <el-select v-model="model.timeUnit" style="width:70px">
+          <el-option :label="$t('workflowEditor.task.day')" value="day" />
+          <el-option :label="$t('workflowEditor.task.hour')" value="hour" />
+        </el-select>
+      </el-form-item>
+      <el-form-item>
+        <el-radio v-model="showNotice" :label="false">
+          {{ $t('workflowEditor.task.alwaysUrging') }}
+        </el-radio>
+        <el-radio v-model="showNotice" :label="true">
+          {{ $t('workflowEditor.task.limitedUrging') }}
+        </el-radio>
+      </el-form-item>
+      <div v-if="showNotice">
+        <el-form-item :label="$t('workflowEditor.task.timesOfUrging')" size="mini">
+          <el-input-number v-model="model.remindTimes" controls-position="right" :min="1" :max="99" style="width:90px" />
+        </el-form-item>
+        <common-notice-tool v-model="model.noticeType" :label="$t('workflowEditor.common.notificationMethod')" />
+        <el-form-item :label="$t('workflowEditor.common.notifyPersonnel')" style="margin-bottom:5px">
+          <el-checkbox v-model="model.containTransferUser">
+            {{ $t('workflowEditor.task.includingHandoverPersonnel') }}
+          </el-checkbox>
+        </el-form-item>
+        <el-form-item label-width="0">
+          <common-user-condition v-model="model.noticeUserCondition" />
+        </el-form-item>
+        <el-form-item :label="$t('workflowEditor.task.handoverPersonnel')" style="margin-bottom:5px">
+          <el-checkbox v-model="model.containNoticeUser">
+            {{ $t('workflowEditor.task.includeNotifyPeople') }}
+          </el-checkbox>
+        </el-form-item>
+        <el-form-item label-width="0">
+          <common-user-condition v-model="model.transferUserCondition" />
+        </el-form-item>
+      </div>
+    </div>
+  </el-form>
+</template>
+<script>
+import CommonNoticeTool from './common-notice-tool'
+import CommonUserCondition from './common-user-condition'
+import SelectMailTemplates from '../common/select-mail-template.vue'
+import Vue from 'vue'
+export default {
+  name: 'Reminder',
+  components: {
+    CommonNoticeTool,
+    CommonUserCondition,
+    SelectMailTemplates
+  },
+  props: {
+    value: {
+      type: [Object, String],
+      default: null
+    }
+  },
+  data() {
+    let showReminder = false
+    let showNotice = false
+    let model = {
+      dueDate: 1,
+      dueTimeUnit: 'day',
+      repeat: 1,
+      containTransferUser: false,
+      containNoticeUser: false,
+      remindType: 'mail',
+      timeUnit: 'day',
+      remindTimes: 0,
+      noticeType: '',
+      noticeUserCondition: '',
+      transferUserCondition: ''
+    }
+    if (this.value !== null && this.value !== undefined && this.value !== '') {
+      model = this.value
+      showReminder = true
+      if (this.value.remindTimes > 0) {
+        showNotice = true
+      }
+      if (!model.dueTimeUnit) {
+        model.dueTimeUnit = 'day'
+      }
+    }
+    return {
+      showReminder,
+      showNotice,
+      model,
+      showMailTemplateFlag: false,
+      baseURL: '',
+      optionUrl: '',
+      multiSelectData: [],
+      options: {
+        showColumns: 'code,name'
+      }
+    }
+  },
+  watch: {
+    showReminder(val) {
+      if (val) {
+        this.$emit('input', this.model)
+      } else {
+        this.$emit('input', null)
+      }
+    },
+    showNotice(val) {
+      if (val) {
+        this.$emit('input', this.model)
+      } else {
+        // 复制model的值发送出去，不修改model的值，这样用户来回切换选项或者页签的时候，值还在，但是一旦关闭就没有了
+        this.$emit('input', {
+          remindType: this.model.remindType,
+          dueDate: this.model.dueDate,
+          dueTimeUnit: this.model.dueTimeUnit,
+          repeat: this.model.repeat,
+          timeUnit: this.model.timeUnit,
+
+          remindTimes: 0,
+          noticeType: '',
+          noticeUserCondition: '',
+          containTransferUser: false,
+          transferUserCondition: '',
+          containNoticeUser: false
+        })
+      }
+    }
+  },
+  created() {
+    this.baseURL = Vue.prototype.baseURL
+    this.optionUrl = '/bs/email-templates/list/0'
+    // inform在xml中可能是没有的，所以不能直接使用inform作为model
+    // 通过deep监听model把设置的值返回给流程的inform属性
+    this.$watch('model', function(newVal, oldVal) {
+      let reminder = null
+      if (this.showReminder) {
+        reminder = this.model
+        if (!reminder.dueTimeUnit) {
+          reminder.dueTimeUnit = 'day'
+        }
+      }
+      console.log(reminder)
+      this.$emit('input', reminder)
+    }, {
+      deep: true
+    })
+  },
+  methods: {
+    // 关闭选择邮件模板弹框
+    setMailTemplateCode(mailTemplateCode) {
+      this.model.noticeMailTemplateCode = mailTemplateCode
+    },
+    selectData(selection, row) {
+      this.multiSelectData = selection
+    }
+  }
+}
+</script>
+<style scoped>
+span{
+  margin:0 10px;
+}
+</style>

package/packages/workflow-editor/src/properties-editors/common/select-mail-template.vue

@@ -0,0 +1,83 @@
+<template>
+  <span style="width:100%">
+    <el-input
+      v-model="code"
+    >
+      <i slot="suffix" class="el-input__icon el-icon-search" @click="showMailTemplateFlag = true" />
+    </el-input>
+    <el-dialog
+      width="40%"
+      :title="$t('workflowEditor.task.selectTemplate')"
+      :visible.sync="showMailTemplateFlag"
+      center
+      top="5vh"
+      append-to-body
+      custom-class="properties-editor-noTab"
+    >
+      <super-grid
+        ref="reportGrid"
+        :url="baseURL + optionUrl"
+        code="BS_EMAIL_TEMPLATE"
+        :options="options"
+        @select="selectData"
+      />
+      <span slot="footer" class="dialog-footer">
+        <el-button @click="showMailTemplateFlag = false">{{ $t('workflowEditorPublicModel.cancel') }}</el-button>
+        <el-button type="primary" @click="selectTemplate">{{ $t('workflowEditorPublicModel.determine') }}</el-button>
+      </span>
+    </el-dialog>
+  </span>
+</template>
+
+<script>
+import Vue from 'vue'
+export default {
+  name: 'SelectMailTemplates',
+  model: {
+    prop: 'value',
+    event: 'input'
+  },
+  props: {
+    value: {
+      type: String,
+      default: ''
+    }
+  },
+  data() {
+    const code = this.value
+    return {
+      baseURL: '',
+      optionUrl: '',
+      multiSelectData: [],
+      showMailTemplateFlag: false,
+      code,
+      options: {
+        showColumns: 'code,name'
+      }
+    }
+  },
+  created() {
+    this.baseURL = Vue.prototype.baseURL
+    this.optionUrl = '/mc/email-templates/list/0'
+  },
+  methods: {
+    selectTemplate() {
+      if (!this.multiSelectData || this.multiSelectData.length !== 1) {
+        this.$message({
+          showClose: true,
+          type: 'warning',
+          message: this.$t('workflowEditorMessage.pleaseSelectARow')
+        })
+      } else {
+        this.code = this.multiSelectData[0].code
+        this.$emit('set-value', this.code)
+        this.showMailTemplateFlag = false
+      }
+    },
+    selectData(selection, row) {
+      this.multiSelectData = selection
+    }
+  }
+}
+</script>
+

package/packages/workflow-editor/src/properties-editors/common/standard-fields.vue

@@ -0,0 +1,65 @@
+<template>
+  <el-dialog
+    width="30%"
+    :title="$t('workflowEditorMessage.selectStandardFields')"
+    :visible="true"
+    center
+    top="10vh"
+    append-to-body
+    custom-class="properties-editor-noTab"
+    @close="$emit('close')"
+  >
+    <el-radio-group v-model="seletedField" class="group">
+      <div v-for="field in fields" :key="field.name" class="item">
+        <el-radio :label="field.name">
+          {{ field.label }}
+        </el-radio>
+      </div>
+    </el-radio-group>
+    <span slot="footer" class="dialog-footer">
+      <el-button type="primary" size="small" @click="setField">
+        {{ $t('workflowEditorPublicModel.determine') }}
+      </el-button>
+      <el-button size="small" @click="$emit('close')">
+        {{ $t('workflowEditorPublicModel.cancel') }}
+      </el-button>
+    </span>
+  </el-dialog>
+</template>
+
+<script>
+export default {
+  name: 'StandardFields',
+  props: {
+    fields: {
+      type: Array,
+      default: null
+    }
+  },
+  data() {
+    return {
+      seletedField: null
+    }
+  },
+  methods: {
+    setField() {
+      this.$emit('close', this.seletedField)
+    }
+  }
+}
+</script>
+
+<style lang="scss" scoped>
+  .group {
+    font-size: 14px;
+    text-align:center;
+    width:100%;
+  }
+
+  .item {
+    margin-right: auto;
+    margin-left:auto;
+    margin-bottom: 18px;
+  }
+
+</style>

package/packages/workflow-editor/src/properties-editors/common/system-role-tree-inline.vue

@@ -0,0 +1,355 @@
+<template>
+  <div>
+    <el-input v-model="filterText" :placeholder="$t('workflowEditorMessage.pleaseEnterTheRoleName')" @keyup.enter="clickSearch">
+      <el-button slot="append" icon="el-icon-search" @click="clickSearch" />
+    </el-input>
+    <el-tree
+      ref="roleTree"
+      :props="defaultProps"
+      :load="loadNode"
+      lazy
+      :highlight-current="true"
+      node-key="nodeId"
+      :show-checkbox="multiple"
+      check-strictly
+      :render-content="renderContent"
+      :filter-node-method="filterNode"
+      @check="handleCheckNode"
+      @node-click="handleNodeClick"
+    />
+  </div>
+</template>
+<style>
+.searchResult {
+  color:red
+}
+.inline-input-custom {
+  width : 90%
+}
+</style>
+<script>
+export default {
+  name: 'InlineSystemRoleTree',
+  props: {
+    multiple: {
+      type: Boolean,
+      default: false
+    }
+  },
+  data() {
+    return {
+      systemRoleTrees: null,
+      filterText: '',
+      defaultProps: {
+        id: 'id',
+        label: 'label',
+        children: 'children',
+        isLeaf: 'leaf'
+      },
+      containBranch: false, // 当前租户内是否包含分支机构。获得当前选中角色名称时，如果有分支，则需要将分支名称返回给用户，例如：普通用户/分支1
+      tenantInfo: null, // 公司信息
+      tenantNodeId: -1, // 公司节点的id
+      allSearchNodeIds: [], // 用于保存所有查询出的节点id
+      allExpandNodeIds: [], // 用于保存allSearchNodeIds中所有已加载子节点的id集合
+      isClickNode: false,
+      searchValue: null,
+      selectNodeInfo: null // 单选时选中的结果
+
+    }
+  },
+  computed: {
+  },
+  watch: {
+    filterText(val) {
+      if (!val) {
+        this.searchValue = val
+        // 清空查询内容时，重新加载整个树
+        this.loadRole(this.tenantNodeId, this.tenantNodeId + '')
+      }
+    }
+  },
+  created() {
+  },
+  methods: {
+    // 初始化树 或 点击三角展开节点时动态加载子节点
+    loadNode(node, resolve) {
+      var parentId = 0
+      var parentNodeId
+      if (node.level === 0) {
+        // 表示初始化树
+        parentId = 0
+        parentNodeId = parentId + ''
+      } else {
+        parentId = node.data.id
+        parentNodeId = node.data.nodeId
+      }
+      var checkedKeys = []
+      if (this.$refs.roleTree) {
+        checkedKeys = this.$refs.roleTree.getCheckedKeys()
+      }
+      // 初始化角色树
+      this.initLoadRole(parentId, parentNodeId, node, resolve, checkedKeys)
+    },
+    // 初始化部门树
+    initLoadRole(parentId, parentNodeId, node, resolve, checkedKeys) {
+      this.$http.get(this.baseAPI + '/acs/roles/system-role-trees/' + parentId).then(data => {
+        resolve(data)
+        // 更新当前点击的节点的子节点
+        this.$refs.roleTree.updateKeyChildren(parentNodeId, data)
+        if (parentId === 0) {
+          // 初始化树时，展开公司节点
+          const tenantData = data[0].data
+          this.tenantInfo = JSON.parse(tenantData)
+          this.containBranch = data[0].containBranch
+          // 加载整个组织结构树时，展开公司节点
+          this.loadRole(this.tenantNodeId, this.tenantNodeId + '')
+        }
+
+        if (this.isClickNode) {
+          // 点击当前节点时，加载树节点时
+          // 注意不是点击复选框时
+          this.isClickNode = false
+          this.checkedNodeAndChildren(node.data)
+        } else {
+          // 表示是点击三角展开节点时
+          if (checkedKeys && checkedKeys.indexOf(parentNodeId) > -1) {
+            // 点击部门名称前的三角标识展开节点时，保持当前节点的选中状态
+            // 表示当前展开的节点是选中状态，则应保持其选中状态，并选中其子节点
+            this.checkedNodeAndChildren(node.data)
+          }
+        }
+      })
+    },
+    // 加载当前节点的子节点
+    loadRole(parentId, nodeId, isSearch, searchValue) {
+      this.$http.get(this.baseAPI + '/acs/roles/system-role-trees/' + parentId).then(children => {
+        this.$refs.roleTree.updateKeyChildren(nodeId, children)
+        if (this.$refs.roleTree.store.nodesMap[nodeId]) {
+          this.$refs.roleTree.store.nodesMap[nodeId].expanded = true
+        }
+        if (isSearch) {
+          // 查询时处理
+          if (this.allExpandNodeIds.indexOf(nodeId) === -1) {
+            // allExpandNodeIds集合中是否包含当前parentId节点id
+            this.allExpandNodeIds.push(nodeId)
+          }
+          if (this.allExpandNodeIds.length === this.allSearchNodeIds.length) {
+            // 表示所有节点已展开，执行树的过滤方法
+            this.$refs.roleTree.filter(searchValue)
+            this.allExpandNodeIds = []
+            this.allSearchNodeIds = []
+          }
+        }
+      })
+    },
+    clickSearch() {
+      this.searchValue = this.filterText
+      this.filterAppendNodes(this.filterText)
+    },
+    // 后台查询部门，并拼接树节点
+    filterAppendNodes(value) {
+      this.$http.get(this.baseAPI + '/acs/roles/search-system-role-trees?searchValue=' + value).then(systemIds => {
+        if (systemIds) {
+          if (systemIds.length === 0) {
+            this.$message({
+              showClose: true,
+              type: 'error',
+              message: this.$t('workflowEditorMessage.queryResultIsEmpty')
+            })
+            return
+          }
+          systemIds.forEach(systemId => {
+            const nodeId = 'SYSTEM_' + systemId
+            if (this.allSearchNodeIds.indexOf(nodeId) === -1) {
+              // 表示没有加载过该节点，需要放到allSearchNodeIds集合中,并加载该节点内容
+              this.allSearchNodeIds.push(nodeId)
+              this.loadRole(systemId, nodeId, true, value)
+            }
+          })
+        } else {
+          this.$message({
+            showClose: true,
+            type: 'error',
+            message: this.$t('workflowEditorMessage.queryResultIsEmpty')
+          })
+        }
+      })
+    },
+    // 点击复选框时处理
+    handleCheckNode(data, checkObj) {
+      if (checkObj.checkedKeys.indexOf(data.nodeId) > -1) {
+        // 表示正选中data节点
+        if (data.children) {
+          // 如果已展开，不需要再走后台获得其子节点。只需要选中已有子节点
+          // 展开当前选中的节点
+          this.$refs.roleTree.store.nodesMap[data.nodeId].expanded = true
+          // 选中当前节点及其子节点
+          this.checkedNodeAndChildren(data)
+        } else {
+          // 当前节点未展开。需要走后台获得当前节点的子节点，然后展开当前节点，然后选中这些子节点
+          if (!data.leaf) {
+            // 不是叶子节点，并且没有加载过该父节点的子节点时，需要走后台展开子节点
+            this.$http.get(this.baseAPI + '/acs/roles/system-role-trees/' + data.id).then(result => {
+            // 更新当前点击的节点的子节点
+              this.$refs.roleTree.updateKeyChildren(data.nodeId, result)
+              // 展开当前选中的节点
+              this.$refs.roleTree.store.nodesMap[data.nodeId].expanded = true
+              // 获得所有应该选中的节点
+              this.checkedNodeAndChildren(data)
+            })
+          }
+        }
+      } else {
+        // 表示正取消选中data节点，同时要取消其子节点的选中状态
+        this.cancelChildCheckedNodes(data)
+      }
+    },
+    // 选中当前节点及其子节点
+    checkedNodeAndChildren(data) {
+      // 取消选中状态时，保持节点是展开的状态，不要折叠
+      this.$refs.roleTree.store.nodesMap[data.nodeId].expanded = true
+      // 获得所有应该选中的节点
+      this.$refs.roleTree.setChecked(data.nodeId, true)
+      const children = data.children
+      if (children) {
+        // 递归设置子子节点的选中状态
+        children.forEach(nodeData => {
+          this.checkedNodeAndChildren(nodeData)
+        })
+      }
+    },
+    // 取消当前节点的子节点的选中状态
+    cancelChildCheckedNodes(data) {
+      if (data.id !== this.tenantNodeId) {
+        // 如果当前节点不是公司节点，需要将公司节点的选中状态去掉
+        this.$refs.roleTree.setChecked(this.tenantNodeId + '', false)
+      }
+      const children = data.children
+      if (children) {
+        children.forEach(nodeData => {
+          // 取消节点的选中状态
+          this.$refs.roleTree.setChecked(nodeData.nodeId, false)
+          // 递归取消子子节点的选中状态
+          this.cancelChildCheckedNodes(nodeData)
+        })
+      }
+    },
+    selectRole() {
+      if (this.multiple) {
+        const selectNodeInfo = {
+          containBranch: this.containBranch,
+          roles: []
+        }
+        const selectedRoles = []
+        const checkedNodes = this.$refs.roleTree.getCheckedNodes()
+        checkedNodes.forEach(nodeData => {
+          if (nodeData.nodeType === 'ROLE') {
+            const role = JSON.parse(nodeData.data)
+            role.tenantCode = this.tenantInfo.code
+            role.tenantName = this.tenantInfo.tenantName
+            selectedRoles.push(role)
+          }
+        })
+        selectNodeInfo.roles = selectedRoles
+        if (selectNodeInfo.length > 0) {
+          this.$emit('result', selectNodeInfo)
+        } else {
+          this.$message({
+            showClose: true,
+            type: 'warning',
+            message: this.$t('workflowEditor.pleaseSelectRole')
+          })
+        }
+      } else {
+        if (this.selectNodeInfo) {
+          this.$emit('result', this.selectNodeInfo)
+        } else {
+          this.$message({
+            showClose: true,
+            type: 'warning',
+            message: this.$t('workflowEditor.pleaseSelectRole')
+          })
+        }
+      }
+    },
+    filterNode(value, data, node) {
+      if (!value) {
+        return true
+      } else {
+        var roleName = data.label
+        if (data.nodeType !== 'ROLE') {
+          // 表示不是角色节点
+          return false
+        }
+        return roleName.indexOf(value) !== -1
+      }
+    },
+    handleNodeClick(data, node, nodeTree) {
+      if (this.multiple) {
+        // 多选角色树时，处理点击节点事件
+        this.clickNodeWhenMultiple(data)
+      }
+      console.log(data)
+      if (data.nodeType === 'ROLE' && !this.multiple) {
+        // 点击的是角色节点，并且是单选树时，点击部门节点直接关闭弹框
+        const role = JSON.parse(data.data)
+        role.tenantName = this.tenantInfo.tenantName
+        role.tenantCode = this.tenantInfo.code
+        var selectNodeInfo = {
+          id: data.id,
+          name: data.name,
+          containBranch: this.containBranch,
+          role: role
+        }
+        this.selectNodeInfo = selectNodeInfo
+      }
+    },
+    // 多选树时，点击节点处理复选框的选中状态
+    clickNodeWhenMultiple(data) {
+      var checkedKeys = []
+      if (this.$refs.roleTree) {
+        checkedKeys = this.$refs.roleTree.getCheckedKeys()
+      }
+      if (checkedKeys.indexOf(data.nodeId) > -1) {
+        // 表示当前节点是选中状态，则需要取消其选中状态
+        // 取消当前节点的勾选状态
+        this.$refs.roleTree.setChecked(data.nodeId, false)
+        // 取消当前节点的子节点的勾选状态
+        this.cancelChildCheckedNodes(data)
+        // 取消选中状态时，保持节点是展开的状态，不要折叠
+        this.$refs.roleTree.store.nodesMap[data.nodeId].expanded = true
+      } else {
+        // 表示当前节点不是选中的状态，需要勾选该节点
+        this.$refs.roleTree.setChecked(data.nodeId, true)
+        // 点击树节点时添加并展开节点会走loadNode方法，因为设置了树组件的expand-on-click-node属性为true
+        const children = data.childDepartments
+        if (children && children.length > 0) {
+          // 表示加载过该节点，直接选中即可
+          this.checkedNodeAndChildren(data)
+        } else {
+          // 表示没有加载过该节点，是首次加载，需要走后台
+          // 会走loadNode方法，因为设置了树组件的expand-on-click-node属性为true
+          this.isClickNode = true
+        }
+      }
+    },
+    // 给节点添加查询结果样式
+    renderContent(h, { node, data, store }) {
+      if (data.nodeType && data.nodeType === 'ROLE' &&
+      this.searchValue && data.label.indexOf(this.searchValue) > -1) {
+        // 如果是查询条件
+        return (
+          <span>
+            <span class='searchResult'>{node.label}</span>
+          </span>
+        )
+      }
+      return (
+        <span>
+          <span>{node.label}</span>
+        </span>
+      )
+    }
+  }
+}
+</script>