imatrix-ui 2.8.21-dw → 2.8.21

package/packages/department-user-tree-inline/src/department-user-single-tree-inline.vue

@@ -0,0 +1,269 @@
+<template>
+  <div>
+    <el-container style="height: 395px">
+      <el-header style="font-size: 12px;height: 35px">
+        <el-autocomplete
+          v-model="filterText"
+          :fetch-suggestions="querySearch"
+          :placeholder="$t('departmentUserTree.pleaseEnterUserInformation')"
+          :trigger-on-focus="false"
+          size="small"
+          select-when-unmatched
+          class="inline-input"
+          @keyup.enter.native="clickSearch"
+          @select="handleSelect"
+        >
+          <!-- <el-select slot="prepend" v-model="searchField" class="inline-select-custom">
+            <el-option
+              v-for="item in searchFields"
+              :key="item.value"
+              :label="item.label"
+              :value="item.value"
+            />
+          </el-select> -->
+          <el-button slot="append" icon="el-icon-search" @click="clickSearch" />
+        </el-autocomplete>
+      </el-header>
+      <el-main style="padding: 10px;width: 100%">
+        <div v-if="!searchValue || searchResult.length === 0" style="padding-top:5px;overflow:auto;width: auto;display: inline-block !important;">
+          <el-tree
+            ref="deparmentUserTree"
+            :props="defaultProps"
+            :load="loadNode"
+            lazy
+            node-key="nodeId"
+            :render-content="renderContent"
+            @node-click="handleNodeClick"
+          />
+        </div>
+        <div v-if="searchValue && searchValue.length > 0 && searchResult.length > 0" style="height:100%;overflow: hidden;">
+          <user-result ref="userResult" :grid-data="searchResult" :height="height" :contain-branch="containBranch" :multiple="false" @selectResult="getSelectUser" @resultRowDblclick="resultRowDblclick" />
+        </div>
+      </el-main>
+    </el-container>
+  </div>
+</template>
+<style>
+.searchResult {
+  color:red
+}
+.inline-select-custom {
+  width : 100px
+}
+.inline-input-custom {
+  width : 98%
+}
+</style>
+<script>
+import localStorage from '../../../src/utils/local-storage'
+import UserResult from './search-result'
+import utils from '../../utils/utils'
+import departmentUserTreeSingleService from './department-user-tree-single-service'
+export default {
+  name: 'InlineDepartmentUserSingleTree',
+  components: {
+    UserResult
+  },
+  props: {
+    // 显示指定部门节点及其子节点，不传该属性，表示显示整个组织结构树
+    departmentInfo: {
+      type: Array,
+      default: null
+    },
+    // 弹框的高度
+    height: {
+      type: String,
+      default: '300px'
+    },
+    // 是否需要显示虚拟用户
+    isNeedVirtualUser: {
+      type: Boolean,
+      default: false
+    }
+  },
+  data() {
+    return {
+      filterText: '',
+      defaultProps: {
+        id: 'id',
+        label: 'showName',
+        children: 'children',
+        isLeaf: 'leaf'
+      },
+      searchParam: {
+        userField: null,
+        searchValue: null,
+        treeType: 'MAN_DEPARTMENT_TREE',
+        departmentInfo: null
+      },
+      count: 0,
+      containBranch: false, // 当前租户内是否包含分支机构。获得当前选中用户名称时，如果有分支，则需要将分支名称返回给用户，例如：张三(分支1)
+      tenantNodeId: -1, // 公司节点的id
+      searchFields: [], // 查询的用户属性集合
+      searchField: 'name',
+      restaurants: [], // 查询的备选值
+      searchValue: null, // 查询条件
+      searchResult: [], // 用户的查询结果
+      searchStoreKey: 'searchDepartmentUser',
+      tenantInfo: {}, // 公司根节点信息
+      selectUser: null, // 选择的用户原信息
+      selectNodeInfo: null, // 封装后的用户信息，即用户结果
+      notMultipleClickNum: null, // 节点没有双击事件，手动实现双击事件，参数用来记录次数
+      notMultipleClickNode: null // 节点没有双击事件，手动实现双击事件，参数用来记录节点
+    }
+  },
+  computed: {
+  },
+  watch: {
+    filterText(val) {
+      if (!val) {
+        this.searchValue = val
+        // 清空查询内容时，重新加载整个树
+        if (this.departmentInfo && this.departmentInfo.length > 0) {
+          // 加载指定部门时，展开公司节点
+          this.loadPointDepartments(this)
+        } else {
+          // 加载整个组织结构树时，展开公司节点
+          this.loadDepartment(this.tenantNodeId, this.tenantNodeId + '')
+        }
+      }
+    }
+  },
+  created() {
+    this.searchFields = this.getSearchUserFields()
+  },
+  mounted() {
+    var searchDepartmentUser = localStorage.getObject(this.searchStoreKey)
+    if (searchDepartmentUser) {
+      this.restaurants = searchDepartmentUser
+    } else {
+      this.restaurants = []
+    }
+  },
+  methods: {
+    ...utils,
+    ...departmentUserTreeSingleService,
+    // selectUser(row, column, event) {
+    //   this.packageSelectResult(row)
+    // },
+    handleNodeClick(data, node, nodeTree) {
+      if (this.isUserNode(data)) {
+        const user = JSON.parse(data.data)
+        user.tenantName = this.tenantInfo.tenantName
+        user.tenantCode = this.tenantInfo.code
+        // 点击的是用户节点，并且是单选树时，点击部门节点直接关闭弹框
+        this.packageSelectResult(user)
+        if (this.notMultipleClickNode && this.notMultipleClickNode.id === node.id) {
+          this.notMultipleClickNum++
+          // 表示第二次点击
+          // 判断次数
+          if (this.notMultipleClickNum === 2) {
+            this.notMultipleClickNum = 0
+            this.notMultipleClickNode = null
+            // 关闭弹窗
+            this.$emit('result', this.selectNodeInfo)
+          }
+        } else {
+          this.notMultipleClickNode = node
+          this.notMultipleClickNum = 1
+        }
+        const that = this
+        setTimeout(function() {
+          that.notMultipleClickNum = 0
+          that.notMultipleClickNode = null
+        }, 300)
+      }
+    },
+    packageSelectResult(user) {
+      let name = user.name
+      if (user.enName && user.enName.trim() !== '') {
+        name = name + '(' + user.enName + ')'
+      }
+      if (this.containBranch && user.subCompanyName) {
+        // 如果包含分支机构，则拼接分支机构名称
+        // name = name + '（' + user.subCompanyName + '）'
+      }
+      const selectNodeInfo = {
+        id: user.id,
+        name: name,
+        zhName: user.name,
+        loginName: user.loginName,
+        email: user.email,
+        telephone: user.telephone,
+        containBranch: this.containBranch,
+        user: user,
+        enName: user.enName,
+        subCompanyName: user.subCompanyName
+      }
+      // 表示是勾选单选按钮或 选中树节点
+      this.selectNodeInfo = selectNodeInfo
+    },
+    isUserNode(data) {
+      // 当前节点不是公司节点，节点类型是用户类型时，表示点击的是用户节点
+      return data.id !== this.tenantNodeId && data.nodeType && data.nodeType === 'USER'
+    },
+    confirmSelectUser() {
+      if (this.selectNodeInfo) {
+        this.$emit('result', this.selectNodeInfo)
+      } else {
+        this.$alert(this.$t('imatrixUIMessage.pleaseSelectPersonnel'), this.$t('imatrixUIMessage.tips'), {
+          confirmButtonText: this.$t('imatrixUIPublicModel.sure')
+        })
+      }
+    },
+    // 是否选中了公司节点
+    isSelectTenantNode(dataId) {
+      return dataId === this.tenantNodeId && (!this.departmentInfo || this.departmentInfo.length === 0)
+    },
+    // 初始化树 或 点击三角展开节点时动态加载子节点
+    loadNode(node, resolve) {
+      var parentId = 0
+      var parentNodeId = '0'
+      if (node.level === 0) {
+        // 表示初始化树
+        parentId = 0
+        parentNodeId = parentId + ''
+      } else {
+        parentId = node.data.id
+        parentNodeId = node.data.nodeId
+      }
+      var checkedKeys = []
+      if (this.$refs.deparmentUserTree) {
+        checkedKeys = this.$refs.deparmentUserTree.getCheckedKeys()
+      }
+      // 初始化部门人员树
+      this.initLoadDepartment(parentId, node, resolve, checkedKeys, parentNodeId)
+    },
+    renderContent(h, { node, data, store }) {
+      var className
+      if (node.data.id === -1 || node.data.branch) {
+        // node.id ===-1表示公司节点，node.branch表示是分支机构节点
+        className = 'el-icon-menu'
+      } else if (node.data.id === -2 || node.data.id === -3) {
+        // node.id ===-2表示集团公司无部门用户节点,node.id ===-3表示是分支机构无部门用户节点
+        className = 'el-icon-tickets'
+      } else if (node.data.nodeType === 'USER') {
+        className = 'el-icon-user'
+      } else {
+        className = 'el-icon-date'
+      }
+      return (
+        <span>
+          <i class={className}></i>
+          <span title={node.label}>{node.label}</span>
+        </span>
+      )
+    },
+    getSelectUser(selectUser) {
+      // console.log('getSelectUser==', selectUser)
+      this.selectUser = selectUser
+      // true参数表示是否是勾选单选框，是勾选单选框时不关闭弹框
+      this.packageSelectResult(selectUser)
+    },
+    resultRowDblclick(user) {
+      this.packageSelectResult(user)
+      this.$emit('result', this.selectNodeInfo)
+    }
+  }
+}
+</script>

package/packages/department-user-tree-inline/src/department-user-tree-inline.vue

@@ -0,0 +1,79 @@
+<template>
+  <div>
+    <inline-department-user-multi-tree
+      v-if="multiple"
+      ref="userTree"
+      :height="height"
+      :department-info="departmentInfo"
+      :select-user-info="selectUserInfo"
+      :search-field="searchField"
+      :separator="separator"
+      @result="result"
+    />
+    <inline-department-user-single-tree v-if="!multiple" ref="userTree" :height="height" :department-info="departmentInfo" @result="result" />
+  </div>
+</template>
+<script>
+import InlineDepartmentUserSingleTree from './department-user-single-tree-inline'
+import InlineDepartmentUserMultiTree from './department-user-multiple-tree-inline'
+export default {
+  name: 'InlineDepartmentUserTree',
+  components: {
+    InlineDepartmentUserSingleTree,
+    InlineDepartmentUserMultiTree
+  },
+  props: {
+    // 是否是多选树，默认是true
+    multiple: {
+      type: Boolean,
+      default: true
+    },
+    // 显示指定部门节点及其子节点，不传该属性，表示显示整个组织结构树
+    departmentInfo: {
+      type: Array,
+      default: null
+    },
+    // 弹框的高度
+    height: {
+      type: String,
+      default: '300px'
+    },
+    // 是否需要显示虚拟用户
+    isNeedVirtualUser: {
+      type: Boolean,
+      default: false
+    },
+    // 多选用户树时，已选择用户id或登录名集合，多个之间以逗号隔开
+    selectUserInfo: {
+      type: [String, Number],
+      default: null
+    },
+    // 移除用户时，用户属性名称：id、loginName、email、telephone，默认是loginName
+    searchField: {
+      type: String,
+      default: 'loginName'
+    },
+    // 多选树时结果之间的分隔符，默认是逗号分隔
+    separator: {
+      type: String,
+      default: ','
+    }
+
+  },
+  data() {
+    return {
+      selectNodeInfo: null // 单选时，选择的用户信息
+    }
+  },
+  methods: {
+    result(selectNodeInfo) {
+      this.selectNodeInfo = selectNodeInfo
+      this.$emit('result', selectNodeInfo)
+    },
+    // 嵌入树，多选时，点击确定时调用的方法
+    confirmSelectUser() {
+      this.$refs.userTree.confirmSelectUser()
+    }
+  }
+}
+</script>

package/packages/department-user-tree-inline/src/department-user-tree-multi-service.js

@@ -0,0 +1,230 @@
+import Vue from 'vue'
+import { getI18n } from '../../../src/utils/util'
+import localStorage from '../../../src/utils/local-storage'
+const departmentUserTreeMultiService = {
+  // 后台查询部门，并拼接树节点
+  filterAppendNodes(value) {
+    this.$http.post(Vue.prototype.baseAPI + '/component/organization-trees/search-users', this.searchParam).then(result => {
+      if (result) {
+        if (result.length === 0) {
+          this.searchResult = []
+          this.$message({
+            showClose: true,
+            type: 'error',
+            message: getI18n().t('imatrixUIMessage.queryResultIsEmpty')
+          })
+          return
+        }
+        this.searchResult = result
+      } else {
+        if (result.length === 0) {
+          this.$message({
+            showClose: true,
+            type: 'error',
+            message: getI18n().t('imatrixUIMessage.queryResultIsEmpty')
+          })
+          return
+        }
+      }
+    })
+  },
+  querySearch(queryString, cb) {
+    this.search(this.filterText)
+    cb([])
+  },
+  handleSelect(item) {
+    this.handleSelectUtil(item, localStorage)
+  },
+  search(value) {
+    this.searchValue = value
+    let mySearchValue = value
+    if (mySearchValue) {
+      mySearchValue = mySearchValue.trim()
+    }
+    this.searchParam.searchValue = mySearchValue
+    this.searchParam.departmentInfo = this.departmentInfo
+    // this.searchParam.userField = this.searchField
+    // 后台查询部门，并拼接树节点
+    this.filterAppendNodes(value)
+  },
+  // 点击查询按钮调用的方法
+  clickSearch() {
+    this.selectNodeInfo = null
+    this.storeSeachValue(localStorage, this.searchStoreKey, this.filterText)
+    this.search(this.filterText)
+  },
+  // 选中非叶子类型的部门节点时，首次加载该节点的子节点，需要动态加载该部门下的用户节点及子部门节点，并展开该部门，且选中用户节点
+  dynamicCheckedUserNodes(data) {
+    var param = {
+      parentId: data.id,
+      branchId: data.branchId,
+      needVirtualUser: this.isNeedVirtualUser
+    }
+    this.$http.post(Vue.prototype.baseAPI + '/component/organization-trees/department-users', param).then(result => {
+      // 更新当前点击的节点的子节点
+      this.$refs.deparmentUserTree.updateKeyChildren(data.nodeId, result)
+      this.$refs.deparmentUserTree.store.nodesMap[data.nodeId].expanded = true
+      this.staticCheckedUserNodes(data)
+    })
+  },
+  // 初始化部门人员树
+  initLoadDepartment(parentId, node, resolve, checkedKeys, parentNodeId) {
+    var children = []
+    if (node.data && node.data.children) {
+      children = node.data.children
+    }
+    if (children && children.length > 0) {
+      // 表示加载过该父节点的子节点，只需重新更新一下
+      resolve(children)
+      // 表示当前展开的节点是选中状态，则应保持其选中状态，并选中其子节点
+      if (checkedKeys && checkedKeys.indexOf(parentNodeId) > -1) {
+        // 点击部门名称前的三角标识展开节点时，保持当前节点的选中状态
+        // 表示当前展开的节点是选中状态，则应保持其选中状态，并选中其子节点
+        this.checkedChildrenUserNodes(node.data, node.data.children)
+      }
+    } else {
+    // 表示没有加载过该父节点的子节点集合时
+      const param = {
+        parentId: parentId,
+        needVirtualUser: this.isNeedVirtualUser
+      }
+      if (node.data) {
+        param.branchId = node.data.branchId
+      }
+      this.$http.post(Vue.prototype.baseAPI + '/component/organization-trees/department-users', param).then(data => {
+        resolve(data)
+        // 更新当前点击的节点的子节点，必须加该方法，否则会导致子节点无法选中
+        this.$refs.deparmentUserTree.updateKeyChildren(parentNodeId, data)
+        if (parentId === 0) {
+        // 初始化树时，展开公司节点
+          const tenantData = data[0].data
+          this.tenantInfo = JSON.parse(tenantData)
+          this.containBranch = data[0].containBranch
+          if (this.departmentInfo && this.departmentInfo.length > 0) {
+          // 加载指定部门时，展开公司节点
+            this.loadPointDepartments()
+          } else {
+          // 加载整个组织结构树时，展开公司节点
+            this.loadDepartment(this.tenantNodeId, this.tenantNodeId + '')
+          }
+        }
+        if (this.isClickNode) {
+          // 点击当前节点时，加载树节点时
+          // 注意不是点击复选框时
+          this.isClickNode = false
+          this.staticCheckedUserNodes(node.data)
+        } else {
+          // 表示是点击三角展开节点时
+          if (checkedKeys && checkedKeys.indexOf(parentNodeId) > -1) {
+            // 点击部门名称前的三角标识展开节点时，保持当前节点的选中状态
+            // 表示当前展开的节点是选中状态，则应保持其选中状态，并选中其子节点
+            this.checkedChildrenUserNodes(node.data, node.data.children)
+          }
+        }
+      })
+    }
+  },
+  // 加载当前节点的子节点
+  loadDepartment(parentId, parentNodeId, isSearch, searchValue) {
+    const param = {
+      parentId: parentId,
+      needVirtualUser: this.isNeedVirtualUser
+    }
+    this.$http.post(Vue.prototype.baseAPI + '/component/organization-trees/department-users', param).then(children => {
+      this.$refs.deparmentUserTree.updateKeyChildren(parentNodeId, children)
+      if (this.$refs.deparmentUserTree.store.nodesMap[parentNodeId]) {
+        this.$refs.deparmentUserTree.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.deparmentUserTree.filter(searchValue)
+          this.allExpandNodeIds = []
+          this.allSearchNodeIds = []
+        }
+      }
+    })
+  },
+  // 加载指定部门节点
+  loadPointDepartments() {
+    this.$http.post(Vue.prototype.baseAPI + '/component/organization-trees/point-department-users', this.departmentInfo).then(children => {
+      this.$refs.deparmentUserTree.updateKeyChildren(this.tenantNodeId, children)
+      if (this.$refs.deparmentUserTree.store.nodesMap[this.tenantNodeId]) {
+        this.$refs.deparmentUserTree.store.nodesMap[this.tenantNodeId].expanded = true
+      }
+    })
+  },
+  getChildrenDepartmentUsers(childrenDepartmentIds) {
+    return new Promise((resolve, reject) => {
+      this.$http.post(Vue.prototype.baseAPI + '/component/organization-trees/user-in-departments', childrenDepartmentIds).then(users => {
+        resolve(users)
+      })
+    })
+  },
+  // 根据指定用户信息获得用户集合
+  getSelectUsers(searchField, selectUserInfo, separator) {
+    return new Promise((resolve, reject) => {
+      if (!searchField) {
+        resolve([])
+      } else if (!selectUserInfo) {
+        resolve([])
+      } else {
+        Vue.prototype.$http.get(Vue.prototype.baseAPI + '/component/organization-trees/select-users?searchField=' + searchField + '&selectUserInfo=' + selectUserInfo + '&separator=' + separator).then(users => {
+          resolve(users)
+        }).catch(error => {
+          reject(error)
+        })
+      }
+    })
+  },
+  // 部门人员树选中了组织结构树的根节点
+  packageAllUser() {
+    // 表示集合中不存在该用户，则封装该用户
+    const tenantNodeId = -1
+    var allUser = {
+      id: tenantNodeId,
+      name: '所有用户'
+    }
+    return allUser
+  },
+  // 工作组人员树选中了组织结构树的根节点
+  packageAllWgUser() {
+    // 表示集合中不存在该用户，则封装该用户
+    const tenantNodeId = -1
+    var allUser = {
+      id: tenantNodeId,
+      name: '所有工作组人员'
+    }
+    return allUser
+  },
+  initSelectUsers(searchField, selectUserInfo, separator) {
+    return new Promise((resolve, reject) => {
+      const selectDepts = []
+      if (selectUserInfo) {
+        if (selectUserInfo === '所有用户') {
+          // 表示已选择所有用户
+          selectDepts.push(this.packageAllUser())
+          resolve(selectDepts)
+        } else if (selectUserInfo === '所有工作组人员') {
+          selectDepts.push(this.packageAllWgUser())
+          resolve(selectDepts)
+        } else {
+          // 表示不是选择的所有用户
+          this.getSelectUsers(searchField, selectUserInfo, separator).then(users => {
+            resolve(users)
+          }).catch(error => {
+            reject(error)
+          })
+        }
+      } else {
+        resolve(selectDepts)
+      }
+    })
+  }
+}
+export default departmentUserTreeMultiService

package/packages/department-user-tree-inline/src/department-user-tree-single-service.js

@@ -0,0 +1,122 @@
+import Vue from 'vue'
+import { getI18n } from '../../../src/utils/util'
+import localStorage from '../../../src/utils/local-storage'
+const departmentUserTreeSingleService = {
+  // 后台查询部门，并拼接树节点
+  filterAppendNodes(value) {
+    this.$http.post(Vue.prototype.baseAPI + '/component/organization-trees/search-users', this.searchParam).then(result => {
+      if (result) {
+        this.searchResult = result
+        if (result.length === 0) {
+          this.searchResult = []
+          this.$message({
+            showClose: true,
+            type: 'error',
+            message: getI18n().t('imatrixUIMessage.queryResultIsEmpty')
+          })
+          return
+        }
+      } else {
+        this.searchResult = []
+        if (result.length === 0) {
+          this.$message({
+            showClose: true,
+            type: 'error',
+            message: getI18n().t('imatrixUIMessage.queryResultIsEmpty')
+          })
+          return
+        }
+      }
+    })
+  },
+  querySearch(queryString, cb) {
+    this.search(this.filterText)
+    cb([])
+  },
+  handleSelect(item) {
+    this.handleSelectUtil(item, localStorage)
+  },
+  search(value) {
+    this.searchValue = value
+    let mySearchValue = value
+    if (mySearchValue) {
+      mySearchValue = mySearchValue.trim()
+    }
+    this.searchParam.searchValue = mySearchValue
+    this.searchParam.departmentInfo = this.departmentInfo
+    // this.searchParam.userField = this.searchField
+    // 后台查询部门，并拼接树节点
+    this.filterAppendNodes(value)
+  },
+  // 点击查询按钮调用的方法
+  clickSearch() {
+    this.selectNodeInfo = null
+    this.storeSeachValue(localStorage, this.searchStoreKey, this.filterText)
+    this.search(this.filterText)
+  },
+  // 初始化部门人员树
+  initLoadDepartment(parentId, node, resolve, checkedKeys, parentNodeId) {
+    var children = []
+    if (node.data && node.data.children) {
+      children = node.data.children
+    }
+    if (children && children.length > 0) {
+      // 表示加载过该父节点的子节点，只需重新更新一下
+      resolve(children)
+      // 表示当前展开的节点是选中状态，则应保持其选中状态，并选中其子节点
+      if (checkedKeys && checkedKeys.indexOf(parentNodeId) > -1) {
+        // 点击部门名称前的三角标识展开节点时，保持当前节点的选中状态
+        // 表示当前展开的节点是选中状态，则应保持其选中状态，并选中其子节点
+        this.checkedChildrenUserNodes(node.data, node.data.children)
+      }
+    } else {
+    // 表示没有加载过该父节点的子节点集合时
+      const param = {
+        parentId: parentId,
+        needVirtualUser: this.isNeedVirtualUser
+      }
+      if (node.data) {
+        param.branchId = node.data.branchId
+      }
+      this.$http.post(Vue.prototype.baseAPI + '/component/organization-trees/department-users', param).then(data => {
+        resolve(data)
+        // 更新当前点击的节点的子节点，必须加该方法，否则会导致子节点无法选中
+        this.$refs.deparmentUserTree.updateKeyChildren(parentNodeId, data)
+        if (parentId === 0) {
+        // 初始化树时，展开公司节点
+          const tenantData = data[0].data
+          this.tenantInfo = JSON.parse(tenantData)
+          this.containBranch = data[0].containBranch
+          if (this.departmentInfo && this.departmentInfo.length > 0) {
+          // 加载指定部门时，展开公司节点
+            this.loadPointDepartments(this)
+          } else {
+          // 加载整个组织结构树时，展开公司节点
+            this.loadDepartment(this.tenantNodeId, this.tenantNodeId + '')
+          }
+        }
+      })
+    }
+  },
+  loadDepartment(parentId, parentNodeId, isSearch, searchValue) {
+    const param = {
+      parentId: parentId,
+      needVirtualUser: this.isNeedVirtualUser
+    }
+    this.$http.post(Vue.prototype.baseAPI + '/component/organization-trees/department-users', param).then(children => {
+      this.$refs.deparmentUserTree.updateKeyChildren(parentNodeId, children)
+      if (this.$refs.deparmentUserTree.store.nodesMap[parentNodeId]) {
+        this.$refs.deparmentUserTree.store.nodesMap[parentNodeId].expanded = true
+      }
+    })
+  },
+  loadPointDepartments() {
+    this.$http.post(Vue.prototype.baseAPI + '/component/organization-trees/point-department-users', this.departmentInfo).then(children => {
+      this.$refs.deparmentUserTree.updateKeyChildren(this.tenantNodeId, children)
+      if (this.$refs.deparmentUserTree.store.nodesMap[this.tenantNodeId]) {
+        this.$refs.deparmentUserTree.store.nodesMap[this.tenantNodeId].expanded = true
+      }
+    })
+  }
+}
+export default departmentUserTreeSingleService