imatrix-ui 2.9.9-dw → 2.9.11-boe1

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

@@ -1,284 +0,0 @@
-<template>
-  <div>
-    <el-container style="height: 395px">
-      <el-header style="text-align: right; font-size: 12px;height: 35px">
-        <el-autocomplete
-          v-model="filterText"
-          size="small"
-          select-when-unmatched
-          class="inline-input inline-input-custom"
-          :fetch-suggestions="querySearch"
-          :placeholder="$t('departmentTreeInline.pleaseEnterDepartmentName')"
-          :trigger-on-focus="false"
-          @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">
-        <div v-if="!searchValue" style="padding-top:5px;overflow:auto;width: auto;display: inline-block !important;">
-          <el-tree
-            ref="deparmentTree"
-            :props="defaultProps"
-            :load="loadNode"
-            lazy
-            :show-checkbox="false"
-            node-key="id"
-            check-strictly
-            :render-content="renderContent"
-            :filter-node-method="filterNode"
-            @check-change="handleCheckChange"
-            @node-expand="handleNodeExpand"
-            @node-click="handleNodeClick"
-          />
-        </div>
-        <div v-if="searchValue && searchValue.length > 0" style="height:100%;overflow: hidden;">
-          <user-result :grid-data="searchResult" :height="height" :multiple="false" :is-search-result="true" @selectResult="getSelectUser" @resultRowDblclick="resultRowDblclick" />
-        </div>
-      </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 departmentTreeService from './department-tree-service'
-import UserResult from './search-result.vue'
-export default {
-  name: 'InlineDepartmentSingleTree',
-  components: {
-    UserResult
-  },
-  props: {
-    // 显示指定部门节点及其子节点，不传该属性，表示显示整个组织结构树
-    departmentInfo: {
-      type: Array,
-      default: null
-    },
-    // 弹框的高度
-    height: {
-      type: String,
-      default: '300px'
-    },
-    // 多选部门树时，已选择部门id或部门名称或编码集合，多个之间以逗号隔开
-    selectDepartmentInfo: {
-      type: [String, Number],
-      default: null
-    },
-    // 移除部门时，部门属性名称：id、name、code，默认是id
-    searchField: {
-      type: String,
-      default: 'id'
-    },
-    // 多选树时结果之间的分隔符，默认是逗号分隔
-    separator: {
-      type: String,
-      default: ','
-    }
-  },
-  data() {
-    return {
-      filterText: '',
-      defaultProps: {
-        id: 'id',
-        label: 'showName',
-        children: 'childDepartments',
-        isLeaf: 'leaf'
-      },
-      searchParam: {
-        searchValue: null,
-        treeType: 'DEPARTMENT_TREE',
-        departmentInfo: null
-      },
-      count: 0,
-      containBranch: false, // 当前租户内是否包含分支机构。获得当前选中部门名称时，如果有分支，则需要将分支名称返回给用户，例如：部门1(分支1)
-      tenantNodeId: -1, // 公司节点的id
-      allSearchNodeIds: [], // 用于保存所有查询出的节点id
-      allExpandNodeIds: [], // 用于保存allSearchNodeIds中所有已加载子节点的id集合
-      isClickNode: false,
-      restaurants: [], // 查询的备选值
-      searchValue: null, // 查询条件
-      searchStoreKey: 'searchDepartment',
-      selectNodeInfo: null, // 单选时，选择的部门信息
-      tenantInfo: {}, // 公司根节点信息
-      searchResult: []
-    }
-  },
-  computed: {
-  },
-  watch: {
-    filterText(val) {
-      if (!val) {
-        this.searchValue = val
-        // 清空查询内容时，重新加载整个树
-        if (this.departmentInfo && this.departmentInfo.length > 0) {
-          // 加载指定部门时，展开公司节点
-          this.loadPointDepartments()
-        } else {
-          // 加载整个组织结构树时，展开公司节点
-          this.loadDepartment(this.tenantNodeId)
-        }
-      }
-    }
-  },
-  mounted() {
-    var searchDepartment = localStorage.getObject(this.searchStoreKey)
-    if (searchDepartment) {
-      this.restaurants = searchDepartment
-    } else {
-      this.restaurants = []
-    }
-  },
-  methods: {
-    ...utils,
-    ...departmentTreeService,
-    filterNode(value, data, node) {
-      if (!value) {
-        return true
-      } else {
-        return data.name.indexOf(value) !== -1
-      }
-    },
-    // 选中当前节点及其子节点
-    checkedNodeAndChildren(data) {
-      // 取消选中状态时，保持节点是展开的状态，不要折叠
-      // this.$refs.deparmentTree.store.nodesMap[data.id].expanded = true
-      // 获得所有应该选中的节点
-      this.$refs.deparmentTree.setChecked(data.id, true)
-      const childDepartments = data.childDepartments
-      if (childDepartments) {
-        // 递归设置子子节点的选中状态
-        childDepartments.forEach(nodeData => {
-          this.checkedNodeAndChildren(nodeData)
-        })
-      }
-    },
-    // 取消当前节点的子节点的选中状态
-    cancelChildCheckedNodes(data) {
-      if (data.id !== this.tenantNodeId) {
-        // 如果当前节点不是公司节点，需要将公司节点的选中状态去掉
-        this.$refs.deparmentTree.setChecked(this.tenantNodeId, false)
-      }
-      const childDepartments = data.childDepartments
-      if (childDepartments) {
-        childDepartments.forEach(nodeData => {
-          // 取消节点的选中状态
-          this.$refs.deparmentTree.setChecked(nodeData.id, false)
-          // 递归取消子子节点的选中状态
-          this.cancelChildCheckedNodes(nodeData)
-        })
-      }
-    },
-    handleCheckChange(data, checked, indeterminate) {
-
-    },
-    handleNodeExpand(data, node, nodeTree) {
-    },
-    handleNodeClick(data, node, nodeTree) {
-      this.selectSingleNode(data, false)
-    },
-    selectSingleNode(data, isClickOkBtn) {
-      // 表示是部门树节点
-      if (this.isDepartmentNode(data)) {
-        // 点击的是部门节点，并且是单选树时，点击部门节点直接关闭弹框
-        const department = JSON.parse(data.data)
-        this.packageSelectResult(department)
-        // if (this.selectNodeInfo && isClickOkBtn === true) {
-        // // 点击确定按钮时才需要调result回调事件，关闭弹框
-        //   this.$emit('result', this.selectNodeInfo)
-        // }
-      }
-    },
-    packageSelectResult(department) {
-      department.tenantName = this.tenantInfo.tenantName
-      department.tenantCode = this.tenantInfo.code
-      var selectNodeInfo = {
-        id: department.id,
-        name: department.showName,
-        code: department.code,
-        containBranch: this.containBranch,
-        zhName: department.name,
-        enName: department.enName,
-        department: department
-      }
-      this.selectNodeInfo = selectNodeInfo
-    },
-    isDepartmentNode(data) {
-      // 当前节点不是公司节点，也不是分支机构节点，表示是部门节点
-      return data.id !== this.tenantNodeId && data.nodeType && data.nodeType === 'DEPARTMENT' && !data.branch
-    },
-    selectDepartment() {
-      // 是否需要显示提示框，默认不显示
-      var showTip = false
-      // const data = this.$refs.deparmentTree.getCurrentNode()
-      if (this.selectNodeInfo) {
-        // this.selectSingleNode(data, true)
-        this.$emit('result', this.selectNodeInfo)
-      } else {
-        showTip = true
-      }
-
-      if (showTip) {
-        this.$alert(this.$t('imatrixUIMessage.pleaseSelectDepartment'), this.$t('imatrixUIMessage.tips'), {
-          confirmButtonText: this.$t('imatrixUIPublicModel.sure')
-        })
-      }
-    },
-    // 是否选中了公司节点
-    isSelectTenantNode(dataId) {
-      return dataId === this.tenantNodeId && (!this.departmentInfo || this.departmentInfo.length === 0)
-    },
-    // 给节点添加自定义图标
-    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 {
-        // 表示是部门节点
-        className = 'el-icon-date'
-      }
-      if (data.nodeType && data.nodeType === 'DEPARTMENT' &&
-      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>
-      )
-    },
-    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-tree-inline/src/department-tree-inline.vue

@@ -1,86 +0,0 @@
-<template>
-  <div>
-    <inline-department-multi-tree
-      v-if="multiple"
-      ref="inlineDeparmentTree"
-      :height="height"
-      :check-strictly="checkStrictly"
-      :department-info="departmentInfo"
-      :select-department-info="selectDepartmentInfo"
-      :search-field="searchField"
-      :separator="separator"
-      @result="result"
-    />
-    <inline-department-single-tree
-      v-if="!multiple"
-      ref="inlineDeparmentTree"
-      :department-info="departmentInfo"
-      @result="result"
-    />
-  </div>
-</template>
-
-<script>
-import InlineDepartmentMultiTree from './department-multi-tree-inline.vue'
-import InlineDepartmentSingleTree from './department-single-tree-inline.vue'
-export default {
-  name: 'InlineDepartmentTree',
-  components: {
-    InlineDepartmentMultiTree,
-    InlineDepartmentSingleTree
-  },
-  props: {
-    // 是否是多选树，默认是true
-    multiple: {
-      type: Boolean,
-      default: true
-    },
-    checkStrictly: {
-      type: Boolean,
-      default: false
-    },
-    // 显示指定部门节点及其子节点，不传该属性，表示显示整个组织结构树
-    departmentInfo: {
-      type: Array,
-      default: null
-    },
-    // 弹框的高度
-    height: {
-      type: String,
-      default: '300px'
-    },
-    // 多选部门树时，已选择部门id或部门名称或编码集合，多个之间以逗号隔开
-    selectDepartmentInfo: {
-      type: [String, Number],
-      default: null
-    },
-    // 移除部门时，部门属性名称：id、name、code，默认是id
-    searchField: {
-      type: String,
-      default: 'id'
-    },
-    // 多选树时结果之间的分隔符，默认是逗号分隔
-    separator: {
-      type: String,
-      default: ','
-    }
-  },
-  data() {
-    return {
-      selectNodeInfo: null // 单选时，选择的用户信息
-    }
-  },
-  mounted() {
-  },
-  methods: {
-    result(selectNodeInfo) {
-      this.selectNodeInfo = selectNodeInfo
-      this.$emit('result', selectNodeInfo)
-    },
-    selectDepartment() {
-      this.$refs.inlineDeparmentTree.selectDepartment()
-    }
-
-  }
-}
-</script>

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

@@ -1,245 +0,0 @@
-import Vue from 'vue'
-import { getI18n } from '../../../src/utils/util'
-const departmentTreeService = {
-  // 后台查询部门，并拼接树节点
-  filterAppendNodes(value) {
-    this.$http.post(Vue.prototype.baseAPI + '/component/organization-trees/search-pc-depts', 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
-        // result的格式为[DEPARTMENT~1,DEPARTMENT~1/DEPARTMENT~4,DEPARTMENT~10]
-        // result.forEach(nodeIds => {
-        //   // nodeId的分隔符
-        //   var nodeIdSeparator = '/'
-        //   const nodeIdArr = nodeIds.split(nodeIdSeparator)
-        //   if (nodeIdArr.length > 0) {
-        //     this.loadDepartmentWhenSearch(0, nodeIdArr)
-        //   }
-        // })
-      } else {
-        this.$message({
-          showClose: true,
-          type: 'error',
-          message: getI18n().t('imatrixUIMessage.queryResultIsEmpty')
-        })
-      }
-    })
-  },
-  search(value) {
-    this.searchValue = value
-    let mySearchValue = value
-    if (mySearchValue) {
-      mySearchValue = mySearchValue.trim()
-    }
-    this.searchParam.searchValue = mySearchValue
-    this.searchParam.departmentInfo = this.departmentInfo
-    // 后台查询部门，并拼接树节点
-    this.filterAppendNodes(value)
-  },
-  handleSelect(item) {
-    this.handleSelectUtil(item, localStorage)
-  },
-  querySearch(queryString, cb) {
-    this.search(this.filterText)
-    cb([])
-  },
-  // 点击查询按钮调用的方法
-  clickSearch() {
-    this.storeSeachValue()
-    this.search(this.filterText)
-  },
-  loadDepartmentWhenSearch(n, nodeIdArr) {
-    return new Promise((resolve, reject) => {
-      if (nodeIdArr.length === n) {
-        resolve()
-      } else {
-        const nodeId = nodeIdArr[n]
-        let dataId = nodeId
-        // 节点类型和数据id的分隔符
-        const nodeTypeAndDataIdSeparator = '~'
-        // nodeId格式为DEPARTMENT~4
-        if (nodeId.indexOf(nodeTypeAndDataIdSeparator) > -1) {
-          dataId = nodeId.substring(nodeId.indexOf('~') + 1)
-        }
-        this.loadDepartment(dataId).then(() => {
-          this.loadDepartmentWhenSearch(++n, nodeIdArr)
-        }).catch((error) => {
-          reject(error)
-        })
-      }
-    })
-  },
-  // 点击复选框时处理
-  handleCheckNode(data, checkObj) {
-    if (checkObj.checkedKeys.indexOf(data.id) > -1) {
-      // 表示正选中data节点
-      this.isloading = true
-      if (data.nodeType && data.nodeType === 'DEPARTMENT' && data.data) {
-        // 表示当前选中的节点是部门
-        const department = JSON.parse(data.data)
-        this.selectUser(null, department)
-      }
-      if (data.childDepartments) {
-        // 如果已展开，不需要再走后台获得其子节点。只需要选中已有子节点
-        // 展开当前选中的节点
-        this.$refs.deparmentTree.store.nodesMap[data.id].expanded = true
-        // 选中当前节点及其子节点
-        this.checkedNodeAndChildren(data)
-        this.isloading = false
-      } else {
-        // 当前节点未展开。需要走后台获得当前节点的子节点，然后展开当前节点，然后选中这些子节点
-        if (!data.leaf) {
-          // 不是叶子节点，并且没有加载过该父节点的子节点时，需要走后台展开子节点
-          this.$http.get(Vue.prototype.baseAPI + '/component/organization-trees/departments/' + data.id).then(result => {
-          // 更新当前点击的节点的子节点
-            this.$refs.deparmentTree.updateKeyChildren(data.id, result)
-            // 展开当前选中的节点
-            this.$refs.deparmentTree.store.nodesMap[data.id].expanded = true
-            // 获得所有应该选中的节点
-            this.checkedNodeAndChildren(data)
-          })
-          this.$http.get(Vue.prototype.baseAPI + '/component/organization-trees/child-departments/' + data.id).then(childDepts => {
-            if (childDepts && !this.checkStrictly) {
-              childDepts.forEach(item => {
-                this.selectUser(null, item)
-              })
-              this.isloading = false
-            }
-          })
-        }
-      }
-    } else {
-      // 表示正取消选中data节点，同时要取消其子节点的选中状态
-      this.cancelChildCheckedNodes(data)
-    }
-  },
-  // 初始化树 或 点击三角展开节点时动态加载子节点
-  loadNode(node, resolve) {
-    var parentId = 0
-    if (node.level === 0) {
-      // 表示初始化树
-      parentId = 0
-    } else {
-      parentId = node.data.id
-    }
-    var checkedKeys = []
-    if (this.$refs.deparmentTree) {
-      checkedKeys = this.$refs.deparmentTree.getCheckedKeys()
-    }
-    // 初始化部门树
-    this.initLoadDepartment(parentId, node, resolve, checkedKeys)
-  },
-  // 初始化部门树
-  initLoadDepartment(parentId, node, resolve, checkedKeys) {
-    this.$http.get(Vue.prototype.baseAPI + '/component/organization-trees/departments/' + parentId).then(data => {
-      resolve(data)
-      // 更新当前点击的节点的子节点
-      this.$refs.deparmentTree.updateKeyChildren(parentId, data)
-      if (parentId === 0) {
-        // 初始化树时，展开公司节点
-        const tenantData = data[0].data
-        data[0].disable = true
-        this.tenantInfo = JSON.parse(tenantData)
-        this.containBranch = data[0].containBranch
-        if (this.departmentInfo && this.departmentInfo.length > 0) {
-          // 加载指定部门时，展开公司节点
-          this.loadPointDepartments()
-        } else {
-          // 加载整个组织结构树时，展开公司节点
-          this.loadDepartment(this.tenantNodeId)
-        }
-      }
-
-      if (this.isClickNode) {
-        // 点击当前节点时，加载树节点时
-        // 注意不是点击复选框时
-        this.isClickNode = false
-        this.checkedNodeAndChildren(node.data)
-      } else {
-        // 表示是点击三角展开节点时
-        if (checkedKeys && checkedKeys.indexOf(parentId) > -1) {
-          // 点击部门名称前的三角标识展开节点时，保持当前节点的选中状态
-          // 表示当前展开的节点是选中状态，则应保持其选中状态，并选中其子节点
-          this.checkedNodeAndChildren(node.data)
-        }
-      }
-    })
-  },
-  // 加载当前节点的子节点
-  loadDepartment(parentId, isSearch, searchValue) {
-    return new Promise((resolve, reject) => {
-      this.$http.get(Vue.prototype.baseAPI + '/component/organization-trees/departments/' + parentId).then(children => {
-        this.$refs.deparmentTree.updateKeyChildren(parentId, children)
-        if (this.$refs.deparmentTree.store.nodesMap[parentId]) {
-          this.$refs.deparmentTree.store.nodesMap[parentId].expanded = true
-        }
-        resolve()
-      }).catch((error) => {
-        console.log('error', error)
-      })
-    })
-  },
-  // 加载指定部门节点
-  loadPointDepartments() {
-    this.$http.post(Vue.prototype.baseAPI + '/component/organization-trees/point-departments', this.departmentInfo).then(children => {
-      this.$refs.deparmentTree.updateKeyChildren(this.tenantNodeId, children)
-      if (this.$refs.deparmentTree.store.nodesMap[this.tenantNodeId]) {
-        this.$refs.deparmentTree.store.nodesMap[this.tenantNodeId].expanded = true
-      }
-    })
-  },
-  getSelectDepts(searchField, selectDeptInfo, separator) {
-    return new Promise((resolve, reject) => {
-      if (!searchField) {
-        resolve([])
-      } else if (!selectDeptInfo) {
-        resolve([])
-      } else {
-        this.$http.get(Vue.prototype.baseAPI + '/component/organization-trees/select-departments?searchField=' + searchField + '&selectDeptInfo=' + selectDeptInfo + '&separator=' + separator).then(departments => {
-          resolve(departments)
-        }).catch(error => {
-          reject(error)
-        })
-      }
-    })
-  },
-  // 选中了组织结构树的根节点
-  packageAllDept() {
-    // 表示集合中不存在该用户，则封装该用户
-    var allDept = {
-      id: this.tenantNodeId,
-      name: '所有部门'
-    }
-    return allDept
-  },
-  initSelectDepts() {
-    return new Promise((resolve, reject) => {
-      const selectDepts = []
-      if (this.selectDepartmentInfo) {
-        if (this.selectDepartmentInfo === this.tenantNodeId || this.selectDepartmentInfo === '所有部门') {
-          // 表示已选择所有用户
-          selectDepts.push(this.packageAllDept())
-          resolve(selectDepts)
-        } else {
-          // 表示不是选择的所有用户
-          this.getSelectDepts(this.searchField, this.selectDepartmentInfo, this.separator).then(departments => {
-            resolve(departments)
-          }).catch(error => {
-            reject(error)
-          })
-        }
-      } else {
-        resolve(selectDepts)
-      }
-    })
-  }
-}
-export default departmentTreeService