imatrix-ui 2.9.15-dw-tmp2 → 2.9.16-boe1

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

@@ -1,271 +0,0 @@
-<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')"
-          size="small"
-          class="inline-input searchDepartmentUser"
-          @keyup.enter.native="clickSearch"
-          @select="handleSelect"
-        >
-          <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%
-}
-.searchDepartmentUser {
-  width: 250px
-}
-</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'
-import memoryCacheUtils from '../../utils/memory-cache-utils'
-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, // 节点没有双击事件，手动实现双击事件，参数用来记录节点
-      memoryCacheKey: 'DEPARTMENT_USER_MEMORY_KEY',
-      memoryCacheData: [] // 记忆选择数据, 搜索框获得焦点后，下拉显示最近选中的10个人，倒序排列，最后选中的在最上面显示。
-    }
-  },
-  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 = []
-    }
-    this.getMemoryCacheData('departmentUser')
-  },
-  methods: {
-    ...utils,
-    ...departmentUserTreeSingleService,
-    ...memoryCacheUtils,
-    // 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.setMemoryCacheData(user, 'departmentUser')
-        // 点击的是用户节点，并且是单选树时，点击部门节点直接关闭弹框
-        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
-      // 搜索选中记忆
-      this.setMemoryCacheData(selectUser, 'departmentUser')
-      // 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

@@ -1,79 +0,0 @@
-<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

@@ -1,248 +0,0 @@
-import Vue from 'vue'
-import localStorage from '../../../src/utils/local-storage'
-import { getI18n } from '../../../src/utils/util'
-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) {
-    if (!this.filterText && this.filterText.length === 0) {
-      this.memorySearch(queryString, cb)
-    } else {
-      this.search(this.filterText)
-      cb([])
-    }
-  },
-  handleSelect(item) {
-    // this.handleSelectUtil(item, localStorage)
-    // 查询最新用户信息替换,缓存为历史数据 数据库可能发生变化
-    this.$http.get(Vue.prototype.baseAPI + '/api/users?loginName=' + item.loginName).then(userDTO => {
-      if (userDTO !== null) {
-        for (const dtoKey in userDTO) {
-          if (item.hasOwnProperty(dtoKey)) {
-            item[dtoKey] = userDTO[dtoKey]
-          }
-        }
-      }
-      this.filterText = ''
-      this.searchValue = ''
-      this.selectUser(-1, item)
-      this.setMemoryCacheData(item, 'departmentUser')
-    })
-  },
-  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