imatrix-ui 2.8.21 → 2.8.22-boe10

package/packages/workgroup-tree-inline/src/workgroup-tree-inline.vue

@@ -1,317 +0,0 @@
-<template>
-  <div>
-    <el-container style="height: 395px">
-      <el-header style="text-align: right; font-size: 12px">
-        <el-autocomplete
-          v-model="filterText"
-          select-when-unmatched
-          class="inline-input inline-input-custom"
-          :fetch-suggestions="querySearch"
-          :placeholder="$t('imatrixUIMessage.pleaseEnterTeamName')"
-          :trigger-on-focus="false"
-          @select="handleSelect"
-          @keyup.enter.native="clickSearch"
-        >
-          <el-button slot="append" icon="el-icon-search" @click="clickSearch" />
-        </el-autocomplete>
-      </el-header>
-      <el-main>
-        <el-tree
-          ref="workgroupTree"
-          :props="defaultProps"
-          :load="loadNode"
-          lazy
-          :show-checkbox="multiple"
-          node-key="id"
-          :render-content="renderContent"
-          :filter-node-method="filterNode"
-          @check="handleCheckNode"
-          @node-click="handleNodeClick"
-        />
-      </el-main>
-    </el-container>
-  </div>
-</template>
-<style>
-.searchResult {
-  color:red
-}
-.inline-input-custom {
-  width : 90%
-}
-</style>
-
-<script>
-import localStorage from '../../../src/utils/local-storage'
-import utils from '../../utils/utils'
-import workgroupTreeService from './workgroup-tree-service'
-export default {
-  name: 'InlineWorkgroupTree',
-  props: {
-    // 是否是多选树，默认是true
-    multiple: {
-      type: Boolean,
-      default: true
-    },
-    // 显示指定部门节点及其子节点，不传该属性，表示显示整个组织结构树
-    branchInfo: {
-      type: Array,
-      default: null
-    }
-
-  },
-  data() {
-    return {
-      filterText: '',
-      defaultProps: {
-        id: 'id',
-        label: 'name',
-        children: 'children',
-        isLeaf: 'leaf'
-      },
-      containBranch: false, // 当前租户内是否包含分支机构。获得当前选中部门名称时，如果有分支，则需要将分支名称返回给用户，例如：部门1(分支1)
-      tenantNodeId: -1, // 公司节点的id
-      restaurants: [], // 查询的备选值
-      searchValue: null, // 查询条件
-      searchStoreKey: 'searchWorkgroup',
-      selectNodeInfo: null, // 单选时，选择的工作组信息
-      tenantInfo: {} // 公司根节点信息
-    }
-  },
-  computed: {
-  },
-  watch: {
-    filterText(val) {
-      if (!val) {
-        this.searchValue = val
-        // 清空查询内容时，重新加载整个树
-        this.loadWorkgroup(this.tenantNodeId)
-      }
-    }
-  },
-  mounted() {
-    var searchWorkgroup = localStorage.getObject(this.searchStoreKey)
-    if (searchWorkgroup) {
-      this.restaurants = searchWorkgroup
-    } else {
-      this.restaurants = []
-    }
-  },
-  methods: {
-    ...utils,
-    ...workgroupTreeService,
-    handleSelect(item) {
-      this.handleSelectUtil(item, localStorage)
-    },
-    search(value) {
-      this.searchValue = value
-      this.$refs.workgroupTree.filter(value)
-    },
-    // 点击查询按钮调用的方法
-    clickSearch() {
-      this.storeSeachValue(localStorage, this.searchStoreKey, this.filterText)
-      this.search(this.filterText)
-    },
-    filterNode(value, data, node) {
-      if (!value) {
-        return true
-      } else {
-        var workgroupName = data.name
-        if (data.id === this.tenantNodeId) {
-          // 表示是根节点公司节点
-          return false
-        } else if (this.containBranch) {
-          // 如果包含分支，工作组节点显示的格式为：工作组名称(分支名称)
-          workgroupName = workgroupName.substring(0, workgroupName.lastIndexOf('('))
-        }
-        return workgroupName.indexOf(value) !== -1
-      }
-    },
-    // 点击复选框时处理
-    handleCheckNode(data, checkObj) {
-      if (checkObj.checkedKeys.indexOf(data.id) > -1) {
-        // 表示正选中data节点
-        if (data.id === this.tenantNodeId) {
-          // 表示选中了公司节点
-          this.checkedAllWorkgroups(data)
-        }
-      } else {
-        // 表示正取消选中data节点，同时要取消其子节点的选中状态
-        if (data.id === this.tenantNodeId) {
-          // 表示取消公司节点的选中状态，即取消所有节点的勾选状态
-          this.$refs.workgroupTree.setCheckedKeys([])
-        }
-      }
-    },
-    // 选中了根节点公司节点时，选中所有工作组
-    checkedAllWorkgroups(root) {
-      const children = root.children
-      if (children) {
-        children.forEach(workgroupNode => {
-          this.$refs.workgroupTree.setChecked(workgroupNode.id, true)
-        })
-      }
-    },
-    handleNodeClick(data, node, nodeTree) {
-      if (this.multiple) {
-        // 多选部门树时，处理点击节点事件
-        this.clickNodeWhenMultiple(data)
-      }
-      this.selectSingleNode(data, false)
-    },
-    selectSingleNode(data, isClickOkBtn) {
-      if (this.isWorkgroupNode(data) && !this.multiple) {
-        // 点击的是工作组节点，并且是单选树时，点击部门节点直接关闭弹框
-        const workgroup = JSON.parse(data.data)
-        workgroup.tenantCode = this.tenantInfo.code
-        workgroup.tenantName = this.tenantInfo.tenantName
-        var selectNodeInfo = {
-          id: data.id,
-          name: data.name,
-          code: workgroup.code,
-          containBranch: this.containBranch,
-          workgroup: workgroup
-        }
-        this.selectNodeInfo = selectNodeInfo
-        if (isClickOkBtn === true) {
-          // 点击确定按钮时才需要调result回调事件，关闭弹框
-          this.$emit('result', selectNodeInfo)
-        }
-      }
-    },
-    // 多选树时，点击节点处理复选框的选中状态
-    clickNodeWhenMultiple(data) {
-      var checkedKeys = []
-      if (this.$refs.workgroupTree) {
-        checkedKeys = this.$refs.workgroupTree.getCheckedKeys()
-      }
-      // 取消选中状态时，保持节点是展开的状态，不要折叠
-      this.$refs.workgroupTree.store.nodesMap[data.id].expanded = true
-      if (checkedKeys.indexOf(data.id) > -1) {
-        // 表示当前节点是选中状态，则需要取消其选中状态
-        // 取消当前节点的勾选状态
-        this.$refs.workgroupTree.setChecked(data.id, false)
-        if (data.id === this.tenantNodeId) {
-          // 表示取消公司节点的选中状态，即取消所有节点的勾选状态
-          this.$refs.workgroupTree.setCheckedKeys([])
-        }
-      } else {
-        // 表示当前节点不是选中的状态，需要勾选该节点
-        this.$refs.workgroupTree.setChecked(data.id, true)
-        if (data.id === this.tenantNodeId) {
-          // 表示当前正选中根节点公司节点，则需要勾选所有节点的选中状态
-          this.checkedAllWorkgroups(data)
-        }
-      }
-    },
-    isWorkgroupNode(data) {
-      // 当前节点不是公司节点，也不是分支机构节点，表示是部门节点
-      return data.id !== this.tenantNodeId && data.nodeType && data.nodeType === 'WORKGROUP'
-    },
-    selectWorkgroup() {
-      // 是否需要显示提示框，默认不显示
-      var showTip = false
-      if (this.multiple) {
-        var selectNodeInfo = {
-          ids: [],
-          names: [],
-          codes: [],
-          workgroups: []
-        }
-
-        var nodes = this.$refs.workgroupTree.getCheckedNodes()
-        if (nodes) {
-          if (nodes.length === 0) {
-          // 没有选择任何节点
-            showTip = true
-          } else {
-            for (var i = 0; i < nodes.length; i++) {
-              var node = nodes[i]
-              if (node.id !== this.tenantNodeId) {
-              // 不是公司根节点，表示是工作组节点，直接存到结果集合中
-              // node.data是部门对象的json字符串信息，通过JSON.parse(node.data)将json字符串转为对象
-                const workgroupData = JSON.parse(node.data)
-                this.addSelectedWorkgroupInfo(selectNodeInfo, node, workgroupData)
-              }
-            }
-            if (selectNodeInfo.ids.length > 0) {
-              this.$emit('result', selectNodeInfo)
-            } else {
-              showTip = true
-            }
-          }
-        } else {
-          showTip = true
-        }
-      } else {
-        const data = this.$refs.workgroupTree.getCurrentNode()
-        if (data && data !== null) {
-          this.selectSingleNode(data, true)
-        } else {
-          showTip = true
-        }
-      }
-
-      if (showTip) {
-        this.$alert(this.$t('imatrixUIMessage.pleaseSelectATeam'), this.$t('imatrixUIMessage.tips'), {
-          confirmButtonText: this.$t('imatrixUIPublicModel.sure')
-        })
-      }
-    },
-    // 将选中的部门节点添加到结果集合中
-    addSelectedWorkgroupInfo(result, node, workgroup) {
-      workgroup.tenantCode = this.tenantInfo.code
-      workgroup.tenantName = this.tenantInfo.tenantName
-      result.containBranch = this.containBranch
-      result.ids.push(node.id)
-      result.workgroups.push(workgroup)
-      result.codes.push(workgroup.code)
-      result.names.push(node.name)
-    },
-    // 初始化树 或 点击三角展开节点时动态加载子节点
-    loadNode(node, resolve) {
-      var parentId = 0
-      if (node.level === 0) {
-        // 表示初始化树
-        parentId = 0
-      } else {
-        parentId = node.data.id
-      }
-      var checkedKeys = []
-      if (this.$refs.workgroupTree) {
-        checkedKeys = this.$refs.workgroupTree.getCheckedKeys()
-      }
-      // 初始化部门树
-      this.initLoad(parentId, node, resolve, checkedKeys)
-    },
-    // 给节点添加自定义图标
-    renderContent(h, { node, data, store }) {
-      var className
-      if (node.data.id === -1) {
-        // node.id ===-1表示公司节点，node.branch表示是分支机构节点
-        className = 'el-icon-menu'
-      } else {
-        // 表示是工作组节点
-        className = 'el-icon-date'
-      }
-      if (data.nodeType && data.nodeType === 'WORKGROUP' &&
-      this.searchValue && data.name.indexOf(this.searchValue) > -1) {
-        // 如果是查询条件
-        return (
-          <span>
-            <i class={className}></i>
-            <span class='searchResult' title={node.label}>{node.label}</span>
-          </span>
-        )
-      }
-      return (
-        <span>
-          <i class={className}></i>
-          <span title={node.label}>{node.label}</span>
-        </span>
-      )
-    }
-
-  }
-}
-</script>

package/packages/workgroup-tree-inline/src/workgroup-tree-service.js

@@ -1,43 +0,0 @@
-import Vue from 'vue'
-const workgroupTreeService = {
-  // 初始化部门树
-  initLoad(parentId, node, resolve, checkedKeys) {
-    const param = {
-      parentId: parentId,
-      departmentInfo: this.branchInfo
-    }
-    this.$http.post(Vue.prototype.baseAPI + '/component/organization-trees/workgroups', param).then(data => {
-      resolve(data)
-      // 更新当前点击的节点的子节点
-      this.$refs.workgroupTree.updateKeyChildren(parentId, data)
-      if (parentId === 0) {
-        // 初始化树时，展开公司节点
-        const tenantData = data[0].data
-        this.tenantInfo = JSON.parse(tenantData)
-        this.containBranch = data[0].containBranch
-        // 加载整个组织结构树时，展开公司节点
-        this.loadWorkgroup(this.tenantNodeId)
-      }
-      // 表示是点击三角展开节点时
-      if (checkedKeys && checkedKeys.indexOf(parentId) > -1 && parentId === this.tenantNodeId) {
-        // 点击公司名称前的三角标识展开节点时，保持当前节点的选中状态
-        // 表示当前展开的节点是选中状态，则应保持其选中状态，并选中其子节点
-        this.checkedAllWorkgroups(node.data)
-      }
-    })
-  },
-  // 加载当前节点的子节点
-  loadWorkgroup(parentId) {
-    const param = {
-      parentId: parentId,
-      departmentInfo: this.branchInfo
-    }
-    this.$http.post(Vue.prototype.baseAPI + '/component/organization-trees/workgroups', param).then(children => {
-      this.$refs.workgroupTree.updateKeyChildren(parentId, children)
-      if (this.$refs.workgroupTree.store.nodesMap[parentId]) {
-        this.$refs.workgroupTree.store.nodesMap[parentId].expanded = true
-      }
-    })
-  }
-}
-export default workgroupTreeService

package/packages/workgroup-user-tree/index.js

@@ -1,6 +0,0 @@
-import WorkgroupUserTree from './src/workgroup-user-tree.vue'
-WorkgroupUserTree.install = function(Vue) {
-  Vue.component(WorkgroupUserTree.name, WorkgroupUserTree)
-}
-
-export default WorkgroupUserTree

package/packages/workgroup-user-tree/src/workgroup-user-tree.vue

@@ -1,100 +0,0 @@
-<template>
-  <div>
-    <el-dialog
-      class="user-tree"
-      visible
-      :title="myTitle"
-      :close-on-click-modal="false"
-      append-to-body
-      :width="width"
-      @open="$emit('open')"
-      @opend="$emit('opend')"
-      @close="$emit('close')"
-      @closed="$emit('closed')"
-    >
-      <inline-workgroup-user-tree
-        ref="workgroupUserTree"
-        :multiple="multiple"
-        :branch-info="branchInfo"
-        :select-user-info="selectUserInfo"
-        :search-field="searchField"
-        :separator="separator"
-        @result="result"
-      />
-      <div slot="footer" class="dialog-footer">
-        <el-button size="small" @click="$emit('close')">
-          {{ $t('imatrixUIPublicModel.cancel') }}
-        </el-button>
-        <el-button size="small" type="primary" @click="selectWorkgroupUser">
-          {{ $t('imatrixUIPublicModel.sure') }}
-        </el-button>
-      </div>
-    </el-dialog>
-  </div>
-</template>
-
-<script>
-import InlineWorkgroupUserTree from '../../workgroup-user-tree-inline/src/workgroup-user-tree-inline.vue'
-export default {
-  name: 'WorkgroupUserTree',
-  components: {
-    InlineWorkgroupUserTree
-  },
-  props: {
-    // 是否是多选树，默认是true
-    multiple: {
-      type: Boolean,
-      default: true
-    },
-    // 显示指定部门节点及其子节点，不传该属性，表示显示整个组织结构树
-    branchInfo: {
-      type: Array,
-      default: null
-    },
-    // 弹框的标题
-    title: {
-      type: String,
-      default: null
-    },
-    // 弹框的宽度
-    width: {
-      type: String,
-      default: '30%'
-    },
-    // 多选用户树时，已选择用户id或登录名集合，多个之间以逗号隔开
-    selectUserInfo: {
-      type: [String, Number],
-      default: null
-    },
-    // 移除用户时，用户属性名称：id、loginName、email、telephone，默认是loginName
-    searchField: {
-      type: String,
-      default: 'loginName'
-    },
-    // 多选树时结果之间的分隔符，默认是逗号分隔
-    separator: {
-      type: String,
-      default: ','
-    }
-
-  },
-  data() {
-    let myTitle = this.$t('imatrixUIMessage.pleaseSelectATeam')
-    if (this.title) {
-      myTitle = this.title
-    }
-    return {
-      myTitle
-    }
-  },
-  methods: {
-    result(selectNodeInfo) {
-      this.$emit('close', selectNodeInfo)
-    },
-    // 嵌入树，多选时，点击确定时调用的方法
-    selectWorkgroupUser() {
-      this.$refs.workgroupUserTree.selectWorkgroupUser()
-    }
-  }
-}
-</script>

package/packages/workgroup-user-tree-inline/index.js

@@ -1,6 +0,0 @@
-import InlineWorkgroupUserTree from './src/workgroup-user-tree-inline.vue'
-InlineWorkgroupUserTree.install = function(Vue) {
-  Vue.component(InlineWorkgroupUserTree.name, InlineWorkgroupUserTree)
-}
-
-export default InlineWorkgroupUserTree

package/packages/workgroup-user-tree-inline/src/workgroup-tree-inline-service.js

@@ -1,163 +0,0 @@
-import Vue from 'vue'
-import { getI18n } from '../../../src/utils/util'
-const workgroupTreeInlineService = {
-  // 后台查询部门，并拼接树节点
-  filterAppendNodes(value) {
-    this.$http.post(Vue.prototype.baseAPI + '/component/organization-trees/searches', this.searchParam).then(result => {
-      if (result) {
-        if (result.length === 0) {
-          this.$message({
-            showClose: true,
-            type: 'error',
-            message: getI18n().t('imatrixUIMessage.queryResultIsEmpty')
-          })
-          return
-        }
-        // result的格式为[WORKGROUP~1,WORKGROUP~4,WORKGROUP~10]
-        result.forEach(nodeId => {
-          var dataId = nodeId
-          // 节点类型和数据id的分隔符
-          var nodeTypeAndDataIdSeparator = '~'
-          // nodeId格式为WORKGROUP~4
-          if (nodeId.indexOf(nodeTypeAndDataIdSeparator) > -1) {
-            dataId = nodeId.substring(nodeId.indexOf('~') + 1)
-          }
-          if (this.allSearchNodeIds.indexOf(nodeId) === -1) {
-            // 表示没有加载过该节点，需要放到allSearchNodeIds集合中,并加载该节点内容
-            this.allSearchNodeIds.push(nodeId)
-            this.loadWorkgroup(dataId, nodeId, true, value)
-          }
-        })
-      } else {
-        this.$message({
-          showClose: true,
-          type: 'error',
-          message: getI18n().t('imatrixUIMessage.queryResultIsEmpty')
-        })
-      }
-    })
-  },
-  // 选中节点时
-  checkedNode(data, isClickNode) {
-    const children = data.children
-    if (children && children.length > 0) {
-      // 展开当前选中的节点
-      this.$refs.workgroupUserTree.store.nodesMap[data.nodeId].expanded = true
-      // 选中当前节点及其子节点
-      this.checkedNodeAndChildren(data)
-    } else {
-      if (!data.leaf) {
-        // 不是叶子节点，并且没有加载过该父节点的子节点时，需要走后台展开子节点
-        if (!isClickNode) {
-          var param = {
-            parentId: data.id,
-            departmentInfo: this.branchInfo
-          }
-          this.$http.post(Vue.prototype.baseAPI + '/component/organization-trees/workgroup-users', param).then(result => {
-          // 更新当前点击的节点的子节点
-            this.$refs.workgroupUserTree.updateKeyChildren(data.nodeId, result)
-            // 展开当前选中的节点
-            this.$refs.workgroupUserTree.store.nodesMap[data.nodeId].expanded = true
-            // 获得所有应该选中的节点
-            this.checkedNodeAndChildren(data)
-          })
-        } else {
-          this.isClickNode = true
-        }
-      }
-    }
-  },
-  // 获得所有指定工作组下的用户信息
-  getAllSelectedWorkgroupUsers(parentIds, selectNodeInfo) {
-    this.$http.post(Vue.prototype.baseAPI + '/component/organization-trees/user-in-workgroups', parentIds).then(users => {
-      users.forEach(user => {
-        this.addSelectedUserInfo(selectNodeInfo, user)
-      })
-      if (selectNodeInfo.userIds.length > 0) {
-        this.$emit('result', selectNodeInfo)
-      } else {
-        this.$alert(getI18n().t('imatrixUIMessage.pleaseSelectPersonnel'), getI18n().t('imatrixUIMessage.tips'), {
-          confirmButtonText: getI18n().t('imatrixUIPublicModel.sure')
-        })
-      }
-    })
-  },
-  // 初始化树 或 点击三角展开节点时动态加载子节点
-  loadNode(node, resolve) {
-    var parentId = 0
-    var parentNodeId = '0'
-    if (node.level === 0) {
-      // 表示初始化树
-      parentId = 0
-      parentNodeId = '0'
-    } else {
-      parentId = node.data.id
-      parentNodeId = node.data.nodeId
-    }
-    var checkedKeys = []
-    if (this.$refs.workgroupUserTree) {
-      checkedKeys = this.$refs.workgroupUserTree.getCheckedKeys()
-    }
-    // 初始化部门树
-    this.initLoad(parentId, parentNodeId, node, resolve, checkedKeys)
-  },
-  // 初始化部门树
-  initLoad(parentId, parentNodeId, node, resolve, checkedKeys) {
-    const param = {
-      parentId: parentId,
-      departmentInfo: this.branchInfo
-    }
-    this.$http.post(Vue.prototype.baseAPI + '/component/organization-trees/workgroup-users', param).then(data => {
-      resolve(data)
-      // 更新当前点击的节点的子节点
-      this.$refs.workgroupUserTree.updateKeyChildren(parentNodeId, data)
-      if (parentId === 0) {
-        // 初始化树时，展开公司节点
-        const tenantData = data[0].data
-        this.tenantInfo = JSON.parse(tenantData)
-        this.containBranch = data[0].containBranch
-        // 加载整个组织结构树时，展开公司节点
-        this.loadWorkgroup(this.tenantNodeId, this.tenantNodeId + '')
-      }
-      if (this.isClickNode) {
-        // 表示点击工作组节点选中时展开
-        this.isClickNode = false
-        this.checkedNode(node.data)
-      } else {
-        // 表示是点击三角展开节点时
-        if (checkedKeys && checkedKeys.indexOf(parentNodeId) > -1) {
-          // 点击公司名称前的三角标识展开节点时，保持当前节点的选中状态
-          // 表示当前展开的节点是选中状态，则应保持其选中状态，并选中其子节点
-          this.checkedNode(node.data)
-        }
-      }
-    })
-  },
-  // 加载当前节点的子节点
-  loadWorkgroup(parentId, parentNodeId, isSearch, searchValue) {
-    const param = {
-      parentId: parentId,
-      departmentInfo: this.branchInfo
-    }
-    this.$http.post(Vue.prototype.baseAPI + '/component/organization-trees/workgroup-users', param).then(children => {
-      this.$refs.workgroupUserTree.updateKeyChildren(parentNodeId, children)
-      if (this.$refs.workgroupUserTree.store.nodesMap[parentNodeId]) {
-        this.$refs.workgroupUserTree.store.nodesMap[parentNodeId].expanded = true
-      }
-      if (isSearch) {
-        // 查询时处理
-        if (this.allExpandNodeIds.indexOf(parentNodeId) === -1) {
-          // allExpandNodeIds集合中是否包含当前parentId节点id
-          this.allExpandNodeIds.push(parentNodeId)
-        }
-        if (this.allExpandNodeIds.length === this.allSearchNodeIds.length) {
-          // 表示所有节点已展开，执行树的过滤方法
-          this.$refs.workgroupUserTree.filter(searchValue)
-          this.allExpandNodeIds = []
-          this.allSearchNodeIds = []
-        }
-      }
-    })
-  }
-}
-export default workgroupTreeInlineService