@sy-common/organize-select-help 1.0.0-beta.62 → 1.0.0-beta.64

package/src/index.vue

@@ -7,6 +7,7 @@
       width="1180"
       :mask-closable="false"
       class="modal-tree"
+      :fullscreen="true"
   >
     <div slot="header" class="header-text"><Icon type="md-information" class="icon-tip" />人员选择</div>
     <div class="content-container">
@@ -15,10 +16,14 @@
           <Tabs :value="tabName"  @input="handleTabChange">
             <TabPane label="组织选择" name="org" v-if="name.includes('org')">
               <div class="tab">
-                <span>组织搜索：</span>
-                <Select v-model="orgSearch" filterable :remote-method="getOrgListBySearch" @on-change="getOrgOption" :loading="loadingOrg" placeholder="请输入组织名称" style="width: 600px;" clearable>
-                  <Option v-for="(option, index) in orgSearchList" :value="option.orgUnitId" :key="index">{{option.name}}</Option>
-                </Select>
+                <div class="search-row">
+                  <span class="search-label">组织搜索：</span>
+                  <div class="search-input-wrapper">
+                    <Select v-model="orgSearch" filterable :remote-method="getOrgListBySearch" @on-change="getOrgOption" :loading="loadingOrg" placeholder="请输入组织名称" style="width: 100%;" clearable>
+                      <Option v-for="(option, index) in orgSearchList" :value="option.orgUnitId" :key="index">{{option.name}}</Option>
+                    </Select>
+                  </div>
+                </div>
                 <div class="tag-content" v-if="isQuickOpen && orgTagList.length > 0">
                   <span>快捷选择：</span>
                   <div class="custom-select-wrapper">
@@ -48,7 +53,7 @@
                   </div>
                 </div>
                 <div class="tree">
-                  <organizeTree @handleChange="getOrgList" ref="orgTree" :treeList="orgTree"></organizeTree>
+                  <organizeTree v-if="orgTreeLoaded" @handleChange="getOrgList" ref="orgTree" :treeList="orgTree" :is-custom-tree="true" :disable-lazy-load="false"></organizeTree>
                 </div>
                 <div class="bottom-select">
                   <CheckboxGroup v-model="includeLevelOrg">
@@ -74,10 +79,14 @@
                   </div>
                 </div>
                 <div class="right">
-                  <span>组织搜索：</span>
-                  <Select v-model="postSearch" filterable :remote-method="getPostListBySearch" @on-change="getPostOption" placeholder="组织选择" :loading="loadingPost" clearable @on-clear="handlePostSearchClear" style="width: 365px;">
-                    <Option v-for="(option, index) in postSearchList" :value="option.orgUnitId" :key="index">{{option.name}}</Option>
-                  </Select>
+                  <div class="search-row">
+                    <span class="search-label">组织搜索：</span>
+                    <div class="search-input-wrapper">
+                      <Select v-model="postSearch" filterable :remote-method="getPostListBySearch" @on-change="getPostOption" placeholder="请输入组织名称" :loading="loadingPost" clearable @on-clear="handlePostSearchClear" style="width: 100%;">
+                        <Option v-for="(option, index) in postSearchList" :value="option.orgUnitId" :key="index">{{option.name}}</Option>
+                      </Select>
+                    </div>
+                  </div>
                   <div class="tag-content" v-if="isQuickOpen && postTagList.length > 0">
                     <span>快捷选择：</span>
                     <div class="custom-select-wrapper">
@@ -107,7 +116,7 @@
                     </div>
                   </div>
                   <div class="tree">
-                    <organizeTree @handleChange="getPostList" ref="postTree" :treeList="postTree"></organizeTree>
+                    <organizeTree v-if="postTreeLoaded" @handleChange="getPostList" ref="postTree" :treeList="postTree" :is-custom-tree="true" :disable-lazy-load="false"></organizeTree>
                   </div>
                   <div class="bottom-select">
                     <CheckboxGroup v-model="includeLevelPost">
@@ -128,6 +137,7 @@
                   <div class="tree staff-org-tree">
                     <div class="tree-scroll-force">
                       <organizeTree
+                          v-if="staffTreeLoaded"
                           @handleChange="getStaffList"
                           ref="staffTree"
                           :treeList="staffTree"
@@ -142,7 +152,6 @@
                     </div>
                   </div>
                 </div>
-
                 <div class="staff-right-panel">
                   <Input v-model="staffSearch" @on-enter="searchStaff" @on-search="searchStaff" search placeholder="搜索人员"/>
                   <div style="position:relative;">
@@ -162,10 +171,10 @@
                     </div>
                     <Spin v-if="loadingStaff" size="large" fix />
                   </div>
-<!--                  <div class="bottom-select">-->
-<!--                    <div>当前已选择 <span class="num">{{getCheckedStaff}}</span>人</div>-->
-<!--                    <Button type="primary" icon="md-add" @click="addStaffList">添加人员</Button>-->
-<!--                  </div>-->
+                  <!--                  <div class="bottom-select">-->
+                  <!--                    <div>当前已选择 <span class="num">{{getCheckedStaff}}</span>人</div>-->
+                  <!--                    <Button type="primary" icon="md-add" @click="addStaffList">添加人员</Button>-->
+                  <!--                  </div>-->
                 </div>
               </div>
             </TabPane>
@@ -298,7 +307,14 @@ export default {
       selectedStaffOrgId: '', // 新增：选中的组织节点ID
       proStaffOrgList: [], // 新增：暂存选中的组织节点
       initialDefaultOrgUnitId: '', // 缓存初始defaultOrgUnitId
-      staffTreeInited: false, // 组织树初始化完成标记（用于需求3）
+      // staffTreeInited: false, // 组织树初始化完成标记
+      // 树加载完成标记
+      orgTreeLoaded: false,
+      postTreeLoaded: false,
+      staffTreeLoaded: false,
+      // 缓存原始组织树/岗位树数据
+      originalOrgTree: [], // 组织Tab原始树缓存
+      originalPostTree: [], // 岗位Tab原始树缓存
     }
   },
   mounted() {
@@ -306,79 +322,260 @@ export default {
     this.queryPositionList()
     // this.loadMore()
     this.initialDefaultOrgUnitId = this.defaultOrgUnitId || ''; // 缓存初始值
+    this.initOrgOrgTree()
+    this.initPostOrgTree()
     this.initStaffOrgTree()
   },
 
   methods:{
+    async initOrgOrgTree() {
+      try {
+        this.proOrgList = [];
+        this.orgSearch = '';
+        this.orgSearchList = [];
+        this.orgTreeLoaded = false;
+
+        const orgDetailRes = await ajax.get(`/pub-manage-server/pub/organ/q/queryOrg`, {
+          params: { orgUnitId: '' }
+        });
+
+        if (orgDetailRes.data.code !== 1 || !orgDetailRes.data.data) {
+          this.$Message.warning("未查询到组织根节点，显示空树");
+          this.orgTree = [];
+          this.originalOrgTree = []; // 缓存空数据
+          this.orgTreeLoaded = true;
+          return;
+        }
+
+        const rootOrgData = orgDetailRes.data.data;
+        const leafNode = await this.judgeNodeLeafe(rootOrgData.orgUnitId);
+        const rootNode = this.safeDeepCopy({
+          orgUnitId: rootOrgData.orgUnitId,
+          orgUnitName: rootOrgData.orgUnitName,
+          parentOrgUnitId: rootOrgData.parentOrgUnitId,
+          leafNode: leafNode,
+          title: rootOrgData.orgUnitName || `未命名组织(${rootOrgData.orgUnitId})`,
+          expand: true,
+          orgChildrenList: [],
+          children: []
+        });
+
+        let parentsList = [];
+        try {
+          parentsList = await this.getParentOrgNodesByOrgUnitId(rootOrgData.orgUnitId);
+        } catch (e) {
+          console.warn('父节点查询失败，仅显示根节点:', e);
+          parentsList = [];
+        }
+
+        const safeParents = this.safeDeepCopy(parentsList).map(node => ({
+          orgUnitId: node.orgUnitId,
+          orgUnitName: node.orgUnitName || node.name,
+          parentOrgUnitId: node.parentOrgUnitId || node.parentId,
+          leafNode: false,
+          title: node.orgUnitName || node.name || `未命名组织(${node.orgUnitId})`,
+          expand: true,
+          orgChildrenList: [],
+          children: []
+        }));
+
+        const treeSourceData = [...safeParents, rootNode].filter(Boolean);
+        this.orgTree = this.buildTree(treeSourceData);
+        // 缓存原始树数据
+        this.originalOrgTree = this.safeDeepCopy(this.orgTree);
+
+        if (this.orgTree.length === 0) {
+          this.orgTree = [rootNode];
+          this.originalOrgTree = [rootNode]; // 同步缓存
+        }
+
+        this.orgTreeLoaded = true;
+
+      } catch (e) {
+        console.error("组织选择Tab树初始化失败:", e);
+        this.orgTree = [];
+        this.originalOrgTree = []; // 缓存空数据
+        this.orgTreeLoaded = true;
+        this.$Message.error("组织树初始化失败，请刷新重试");
+      }
+    },
+    async initPostOrgTree() {
+      try {
+        this.proPostList = [];
+        this.postSearch = '';
+        this.postSearchList = [];
+        this.selectedPositionId = null;
+        this.postTreeLoaded = false;
+
+        const orgDetailRes = await ajax.get(`/pub-manage-server/pub/organ/q/queryOrg`, {
+          params: { orgUnitId: '' }
+        });
+
+        if (orgDetailRes.data.code !== 1 || !orgDetailRes.data.data) {
+          this.$Message.warning("未查询到组织根节点，显示空树");
+          this.postTree = [];
+          this.originalPostTree = []; // 缓存空数据
+          this.postTreeLoaded = true;
+          return;
+        }
+
+        const rootOrgData = orgDetailRes.data.data;
+        const leafNode = await this.judgeNodeLeafe(rootOrgData.orgUnitId);
+        const rootNode = this.safeDeepCopy({
+          orgUnitId: rootOrgData.orgUnitId,
+          orgUnitName: rootOrgData.orgUnitName,
+          parentOrgUnitId: rootOrgData.parentOrgUnitId,
+          leafNode: leafNode,
+          title: rootOrgData.orgUnitName || `未命名组织(${rootOrgData.orgUnitId})`,
+          expand: true,
+          orgChildrenList: [],
+          children: []
+        });
+
+        let parentsList = [];
+        try {
+          parentsList = await this.getParentOrgNodesByOrgUnitId(rootOrgData.orgUnitId);
+        } catch (e) {
+          console.warn('岗位Tab父节点查询失败:', e);
+          parentsList = [];
+        }
+
+        const safeParents = this.safeDeepCopy(parentsList).map(node => ({
+          orgUnitId: node.orgUnitId,
+          orgUnitName: node.orgUnitName || node.name,
+          parentOrgUnitId: node.parentOrgUnitId || node.parentId,
+          leafNode: false,
+          title: node.orgUnitName || node.name || `未命名组织(${node.orgUnitId})`,
+          expand: true,
+          orgChildrenList: [],
+          children: []
+        }));
+
+        const treeSourceData = [...safeParents, rootNode].filter(Boolean);
+        this.postTree = this.buildTree(treeSourceData);
+        // 缓存原始树数据
+        this.originalPostTree = this.safeDeepCopy(this.postTree);
+
+        if (this.postTree.length === 0) {
+          this.postTree = [rootNode];
+          this.originalPostTree = [rootNode]; // 同步缓存
+        }
+
+        this.postTreeLoaded = true;
+
+      } catch (e) {
+        console.error("岗位选择Tab树初始化失败:", e);
+        this.postTree = [];
+        this.originalPostTree = []; // 缓存空数据
+        this.postTreeLoaded = true;
+        this.$Message.error("岗位组织树初始化失败，请刷新重试");
+      }
+    },
+
     async initStaffOrgTree() {
       try {
-        // 关键修复：初始化时重置选中状态
+        // 初始化时重置选中状态
         this.$set(this, 'selectedStaffOrgId', '');
         this.proStaffOrgList = [];
-
+        this.staffTreeLoaded = false;
         const rootOrgId = this.defaultOrgUnitId || '';
         let rootNode = null;
         let treeSourceData = []; // 存储树原始数据，避免后续覆盖
 
-        if (rootOrgId) {
-          const orgDetailRes = await ajax.get(`/pub-manage-server/pub/organ/q/queryOrg`, {
-            params: { orgUnitId: rootOrgId }
+        // if (rootOrgId) {
+        //   const orgDetailRes = await ajax.get(`/pub-manage-server/pub/organ/q/queryOrg`, {
+        //     params: { orgUnitId: rootOrgId }
+        //   });
+        //   if (orgDetailRes.data.code === 1 && orgDetailRes.data.data) {
+        //     const orgData = orgDetailRes.data.data;
+        //     const leafNode = await this.judgeNodeLeafe(rootOrgId);
+        //     rootNode = this.safeDeepCopy({
+        //       ...orgData,
+        //       orgNodeName: orgData.orgUnitName || '',
+        //       title: orgData.orgUnitName || `未命名组织(${orgData.orgUnitId || ''})`,
+        //       leafNode,
+        //       expand: true,
+        //       parentOrgUnitId: orgData.parentOrgUnitId || orgData.parentId,
+        //       orgChildrenList: [], // 初始化自定义子节点字段
+        //       children: [] // 初始化 Tree 组件识别的 children 字段
+        //     });
+        //     // 父节点列表同样同步初始化 children 字段
+        //     let parentsList = await this.getParentOrgNodesByOrgUnitId(rootOrgId);
+        //     const safeParents = this.safeDeepCopy(parentsList);
+        //     safeParents.forEach(node => {
+        //       node.expand = true;
+        //       node.parentOrgUnitId = node.parentId;
+        //       node.orgNodeName = node.orgUnitName || node.orgNodeName || '';
+        //       node.title = node.orgUnitName || node.name || `未命名组织(${node.orgUnitId || ''})`;
+        //       node.orgChildrenList = [];
+        //       node.children = []; // 父节点也初始化 children 字段
+        //       node.leafNode = false;
+        //     });
+        //     treeSourceData = [...safeParents, rootNode];
+        //   } else {
+        //     this.$Message.error("根据默认组织ID查询根节点失败！");
+        //     return;
+        //   }
+        // } else {
+        //   // defaultOrgUnitId为空时，沿用原有接口/pub/personHelpBox/q/getOrgUnitList
+        //   const res = await ajax.get('/pub-manage-server/pub/personHelpBox/q/getOrgUnitList', {
+        //     params: { containsCurLevel: true }
+        //   });
+        //   if (res.data.code === 1) {
+        //     rootNode = res.data.data[0] || null;
+        //     if (rootNode) {
+        //       rootNode.expand = true;
+        //       rootNode.parentOrgUnitId = rootNode.parentId;
+        //       treeSourceData = [rootNode];
+        //     }
+        //   }
+        // }
+        const orgDetailRes = await ajax.get(`/pub-manage-server/pub/organ/q/queryOrg`, {
+          params: { orgUnitId: rootOrgId }
+        });
+        if (orgDetailRes.data.code === 1 && orgDetailRes.data.data) {
+          const orgData = orgDetailRes.data.data;
+          const leafNode = await this.judgeNodeLeafe(rootOrgId);
+          rootNode = this.safeDeepCopy({
+            ...orgData,
+            orgNodeName: orgData.orgUnitName || '',
+            title: orgData.orgUnitName || `未命名组织(${orgData.orgUnitId || ''})`,
+            leafNode,
+            expand: true,
+            parentOrgUnitId: orgData.parentOrgUnitId || orgData.parentId,
+            orgChildrenList: [], // 初始化自定义子节点字段
+            children: [] // 初始化 Tree 组件识别的 children 字段
           });
-          if (orgDetailRes.data.code === 1 && orgDetailRes.data.data) {
-            const orgData = orgDetailRes.data.data;
-            const leafNode = await this.judgeNodeLeafe(rootOrgId);
-            rootNode = this.safeDeepCopy({
-              ...orgData,
-              orgNodeName: orgData.orgUnitName || '',
-              title: orgData.orgUnitName || `未命名组织(${orgData.orgUnitId || ''})`,
-              leafNode,
-              expand: true,
-              parentOrgUnitId: orgData.parentOrgUnitId || orgData.parentId,
-              orgChildrenList: [], // 初始化自定义子节点字段
-              children: [] // 关键：初始化 Tree 组件识别的 children 字段
-            });
-            // 父节点列表同样同步初始化 children 字段
-            let parentsList = await this.getParentOrgNodesByOrgUnitId(rootOrgId);
-            const safeParents = this.safeDeepCopy(parentsList);
-            safeParents.forEach(node => {
-              node.expand = true;
-              node.parentOrgUnitId = node.parentId;
-              node.orgNodeName = node.orgUnitName || node.orgNodeName || '';
-              node.title = node.orgUnitName || node.name || `未命名组织(${node.orgUnitId || ''})`;
-              node.orgChildrenList = [];
-              node.children = []; // 父节点也初始化 children 字段
-              node.leafNode = false;
-            });
-            treeSourceData = [...safeParents, rootNode];
-          } else {
-            this.$Message.error("根据默认组织ID查询根节点失败！");
-            return;
-          }
-        } else {
-          // defaultOrgUnitId为空时，沿用原有接口/pub/personHelpBox/q/getOrgUnitList
-          const res = await ajax.get('/pub-manage-server/pub/personHelpBox/q/getOrgUnitList', {
-            params: { containsCurLevel: true }
+          // 父节点列表同样同步初始化 children 字段
+          let parentsList = await this.getParentOrgNodesByOrgUnitId(rootOrgId);
+          const safeParents = this.safeDeepCopy(parentsList);
+          safeParents.forEach(node => {
+            node.expand = true;
+            node.parentOrgUnitId = node.parentId;
+            node.orgNodeName = node.orgUnitName || node.orgNodeName || '';
+            node.title = node.orgUnitName || node.name || `未命名组织(${node.orgUnitId || ''})`;
+            node.orgChildrenList = [];
+            node.children = []; // 父节点也初始化 children 字段
+            node.leafNode = false;
           });
-          if (res.data.code === 1) {
-            rootNode = res.data.data[0] || null;
-            if (rootNode) {
-              rootNode.expand = true;
-              rootNode.parentOrgUnitId = rootNode.parentId;
-              treeSourceData = [rootNode];
-            }
-          }
+          treeSourceData = [...safeParents, rootNode];
+        } else {
+          this.$Message.error("根据默认组织ID查询根节点失败！");
+          this.staffTreeLoaded = true;
+          return;
         }
-
-        // 构建组织树，且仅赋值一次，避免后续覆盖（需求3）
+        // 构建组织树，且仅赋值一次，避免后续覆盖
         if (treeSourceData.length > 0) {
           const tree = this.buildTree(treeSourceData);
           this.staffTree = this.safeDeepCopy(tree);
-          // 关键：标记树已初始化完成，防止后续重复构建覆盖
-          this.staffTreeInited = true;
+          // 标记树已初始化完成，防止后续重复构建覆盖
+          // this.staffTreeInited = true;
+          this.staffTreeLoaded = true;
         }
       } catch (e) {
         this.$Message.error("人员选择组织树初始化失败！");
         console.error(e);
+        this.staffTreeLoaded = true;
       }
     },
     handlePostTagSelect(quickPickKey) {
@@ -503,7 +700,6 @@ export default {
           this.loadingPost = false;
           if (res.data.code === 1) {
             let resp = res.data.data?.items ?? [];
-            // 修复：岗位搜索结果深拷贝，避免引用污染
             this.postSearchList = this.safeDeepCopy(resp);
           } else {
             this.postSearchList = [];
@@ -511,13 +707,15 @@ export default {
           }
         });
       } else {
-        // 修复：清空搜索时，同时清空树数据和暂存列表（与组织Tab一致）
+        // 仅清空搜索结果，不重置树数据
         this.postSearchList = [];
+        // 仅重置选中状态，保留树结构
         if (this.$refs.postTree) {
-          this.$refs.postTree.initData();
+          this.$refs.postTree.initData(); // 清空选中状态
+          this.proPostList = []; // 清空暂存列表
         }
-        this.proPostList = []; // 清空岗位暂存列表
-        this.$set(this, 'postTree', []); // 清空岗位树数据
+        // 移除清空树数据的代码
+        // this.$set(this, 'postTree', []);
       }
     },
     getOrgUnitBySearchTerm(query,callback){
@@ -525,78 +723,138 @@ export default {
     },
     async getOrgOption(val) {
       this.selectedOrgTagKey = '';
-      this.orgTagList.forEach(tag => {
-        tag.checked = false;
-      });
+      this.orgTagList.forEach(tag => tag.checked = false);
       this.proOrgList = [];
-      if(!val) return this.$refs.orgTree.initData();
-      let item = this.orgSearchList.filter((item)=> item.orgUnitId === val).shift();
-      if (!item) return;
+      if (!val) {
+        // 清空搜索时恢复原始树数据，而非置空
+        this.orgTree = this.safeDeepCopy(this.originalOrgTree);
+        // 同步更新子组件数据
+        this.$nextTick(() => {
+          if (this.$refs.orgTree) {
+            this.$refs.orgTree.data = this.safeDeepCopy(this.orgTree);
+            // 重置树选中状态，但保留树结构
+            this.$refs.orgTree.initData();
+          }
+        });
+        return;
+      }
+      const orgDetailRes = await ajax.get(`/pub-manage-server/pub/organ/q/queryOrg`, {
+        params: { orgUnitId: val }
+      });
 
-      const leafNode = await this.judgeNodeLeafe(item.orgUnitId);
-      const ftem = this.safeDeepCopy({
-        ...item,
-        orgNodeName: item.name,
-        parentOrgUnitId: item.parentId,
-        leafNode: leafNode
+      if (orgDetailRes.data.code !== 1 || !orgDetailRes.data.data) {
+        this.$Message.error("获取组织节点详情失败！");
+        return;
+      }
+
+      const nodeData = orgDetailRes.data.data;
+      const currentNode = this.safeDeepCopy({
+        orgUnitId: nodeData.orgUnitId,
+        orgUnitName: nodeData.orgUnitName,
+        parentOrgUnitId: nodeData.parentOrgUnitId,
+        leafNode: nodeData.leafNode || await this.judgeNodeLeafe(nodeData.orgUnitId),
+        title: nodeData.orgUnitName || `未命名组织(${nodeData.orgUnitId})`,
+        expand: true,
+        orgChildrenList: [],
+        children: []
       });
 
-      try{
+      try {
         let parentsList = await this.getParentOrgNodesByOrgUnitId(val);
-        // 对父节点列表进行安全拷贝
-        const safeParents = this.safeDeepCopy(parentsList);
-        let tree = this.buildTree([...safeParents, ftem]);
-        this.orgTree = this.safeDeepCopy(tree);
-      }catch(e){
-        this.$Message.error("获取组织节点列表失败！");
+        const safeParents = this.safeDeepCopy(parentsList).map(node => ({
+          orgUnitId: node.orgUnitId,
+          orgUnitName: node.orgUnitName || node.name,
+          parentOrgUnitId: node.parentOrgUnitId || node.parentId,
+          leafNode: false,
+          title: node.orgUnitName || node.name || `未命名组织(${node.orgUnitId})`,
+          expand: true,
+          orgChildrenList: [],
+          children: []
+        }));
+
+        const treeSourceData = [...safeParents, currentNode].filter(Boolean);
+        this.orgTree = this.buildTree(treeSourceData);
+
+        // 强制更新子组件数据
+        this.$nextTick(() => {
+          if (this.$refs.orgTree) {
+            this.$refs.orgTree.data = this.safeDeepCopy(this.orgTree);
+          }
+        });
+      } catch (e) {
+        this.$Message.error("更新组织树失败！");
       }
     },
     async getPostOption(val) {
-      // 1. 重置选中的标签key
       this.selectedPostTagKey = '';
+      this.postTagList.forEach(tag => tag.checked = false);
 
-      // 2. 重置所有标签的选中状态
-      this.postTagList.forEach(tag => {
-        tag.checked = false;
-      });
       if (!val) {
-        // 修复：岗位树清空时，同时清空暂存列表和搜索框
-        if (this.$refs.postTree) {
-          this.$refs.postTree.initData();
-        }
-        this.proPostList = []; // 清空岗位暂存列表（与组织Tab保持一致）
-        this.postSearch = ''; // 清空搜索框
+        // 清空搜索时恢复原始树数据
+        this.postTree = this.safeDeepCopy(this.originalPostTree);
+        this.proPostList = [];
+        this.postSearch = '';
+        // 同步更新子组件数据
+        this.$nextTick(() => {
+          if (this.$refs.postTree) {
+            this.$refs.postTree.data = this.safeDeepCopy(this.postTree);
+            // 重置树选中状态，但保留树结构
+            this.$refs.postTree.initData();
+          }
+        });
         return;
       }
 
-      let item = this.postSearchList.filter(item => item.orgUnitId === val).shift();
-      if (!item) return;
+      // 原有逻辑保持不变
+      const orgDetailRes = await ajax.get(`/pub-manage-server/pub/organ/q/queryOrg`, {
+        params: { orgUnitId: val }
+      });
 
-      const leafNode = await this.judgeNodeLeafe(item.orgUnitId);
-      // 修复：岗位节点深拷贝，避免引用污染
-      const ftem = this.safeDeepCopy({
-        ...item,
-        orgNodeName: item.name || `未命名组织(${item.orgUnitId})`,
-        parentOrgUnitId: item.parentId,
-        leafNode: leafNode
+      if (orgDetailRes.data.code !== 1 || !orgDetailRes.data.data) {
+        this.$Message.error("获取组织节点详情失败！");
+        return;
+      }
+
+      const nodeData = orgDetailRes.data.data;
+      const currentNode = this.safeDeepCopy({
+        orgUnitId: nodeData.orgUnitId,
+        orgUnitName: nodeData.orgUnitName,
+        parentOrgUnitId: nodeData.parentOrgUnitId,
+        leafNode: nodeData.leafNode || await this.judgeNodeLeafe(nodeData.orgUnitId),
+        title: nodeData.orgUnitName || `未命名组织(${nodeData.orgUnitId})`,
+        expand: true,
+        orgChildrenList: [],
+        children: []
       });
 
       try {
         let parentsList = await this.getParentOrgNodesByOrgUnitId(val);
-        const safeParents = this.safeDeepCopy(parentsList);
-        let tree = this.buildTree([...safeParents, ftem]);
-        // 修复：用$set确保岗位树数据响应式更新
-        this.$set(this, 'postTree', this.safeDeepCopy(tree));
+        const safeParents = this.safeDeepCopy(parentsList).map(node => ({
+          orgUnitId: node.orgUnitId,
+          orgUnitName: node.orgUnitName || node.name,
+          parentOrgUnitId: node.parentOrgUnitId || node.parentId,
+          leafNode: false,
+          title: node.orgUnitName || node.name || `未命名组织(${node.orgUnitId})`,
+          expand: true,
+          orgChildrenList: [],
+          children: []
+        }));
+
+        const treeSourceData = [...safeParents, currentNode].filter(Boolean);
+        this.postTree = this.buildTree(treeSourceData);
 
-        // 修复：设置节点展开和选中（与组织Tab逻辑一致）
         this.$nextTick(() => {
           if (this.$refs.postTree && this.$refs.postTree.setCheckedNodes) {
-            this.$refs.postTree.setCheckedNodes([val]); // 选中当前节点
-            this.proPostList = [ftem]; // 同步暂存列表
+            this.$refs.postTree.setCheckedNodes([val]);
+            this.proPostList = [currentNode];
+          }
+          // 强制更新子组件数据
+          if (this.$refs.postTree) {
+            this.$refs.postTree.data = this.safeDeepCopy(this.postTree);
           }
         });
       } catch (e) {
-        this.$Message.error("获取组织节点列表失败！");
+        this.$Message.error("更新岗位组织树失败！");
       }
     },
     async getStaffOption(val) {
@@ -623,67 +881,84 @@ export default {
         this.$Message.error("获取组织节点列表失败！");
       }
     },
-    getParentOrgNodesByOrgUnitId(val){
-      return new Promise((resolve,reject)=>{
-        ajax.get('/pub-manage-server/pub/personHelpBox/q/getParentOrgNodesByOrgUnitId?orgUnitId='+val).then((res)=>{
-          if(res.data.code === 1){
-            let parentsList = res.data?.data?.items??[]
-            resolve(parentsList)
-          }else{
-            reject(false)
-          }
-        })
-      })
+    getParentOrgNodesByOrgUnitId(val) {
+      return new Promise((resolve) => {
+        ajax.get('/pub-manage-server/pub/personHelpBox/q/getParentOrgNodesByOrgUnitId?orgUnitId='+val)
+            .then((res) => {
+              if (res.data.code === 1) {
+                const parentsList = res.data?.data?.items ?? [];
+                resolve(parentsList); // 接口正常返回则取数据
+              } else {
+                resolve([]); // 接口报错返回空数组
+              }
+            })
+            .catch(() => {
+              resolve([]); // 网络/请求失败返回空数组
+            });
+      });
     },
-    judgeNodeLeafe(orgUnitId){
-      return new Promise((resolve,reject)=>{
-        ajax.get('/pub-manage-server/pub/personHelpBox/q/getOrgUnitList', { params:{
-            containsCurLevel:true,
-            orgUnitId:orgUnitId,
+    judgeNodeLeafe(orgUnitId) {
+      return new Promise((resolve) => {
+        ajax.get('/pub-manage-server/pub/personHelpBox/q/getOrgUnitList', {
+          params: {
+            containsCurLevel: true,
+            orgUnitId: orgUnitId,
           }
-        }).then((res)=>{
-          if(res.data.code === 1){
-            let treeList = res.data.data
-            if(treeList && treeList.length){
-              resolve(false)
-            }else{
-              resolve(true)
-            }
-          }else{
-            resolve(false)
+        }).then((res) => {
+          if (res.data.code === 1) {
+            const treeList = res.data.data || [];
+            resolve(treeList.length === 0);
+          } else {
+            resolve(false); // 接口失败默认非叶子节点
           }
-        })
-      })
+        }).catch(() => {
+          resolve(false); // 网络错误默认非叶子节点
+        });
+      });
     },
     buildTree(items) {
-      const map = {};
+      if (!Array.isArray(items) || items.length === 0) {
+        console.warn('构建树入参为空，返回空数组');
+        return [];
+      }
+
+      const map = new Map();
       const roots = [];
       const copiedItems = this.safeDeepCopy(items);
 
       copiedItems.forEach(item => {
         if (!item.orgUnitId) return;
-        map[item.orgUnitId] = this.safeDeepCopy({
-          ...item,
-          orgChildrenList: [],
-          children: [], // 强制初始化 children 空数组
-          title: item.orgUnitName || item.orgNodeName || item.name || `未命名组织(${item.orgUnitId || ''})`
-        });
+        map.set(item.orgUnitId, this.safeDeepCopy({
+          orgUnitId: item.orgUnitId,
+          orgUnitName: item.orgUnitName,
+          parentOrgUnitId: item.parentOrgUnitId,
+          leafNode: item.leafNode || false,
+          title: item.title || item.orgUnitName || `未命名组织(${item.orgUnitId})`,
+          expand: item.expand || true, // 保留展开状态
+          orgChildrenList: item.orgChildrenList || [],
+          children: item.children || []
+        }));
       });
 
       copiedItems.forEach(item => {
-        if (!item.orgUnitId || !map[item.orgUnitId]) return;
+        if (!item.orgUnitId || !map.has(item.orgUnitId)) return;
 
-        const node = map[item.orgUnitId];
-        if (!item.parentOrgUnitId || !map[item.parentOrgUnitId]) {
+        const node = map.get(item.orgUnitId);
+        if (!item.parentOrgUnitId || !map.has(item.parentOrgUnitId)) {
           roots.push(node);
         } else {
-          const parent = map[item.parentOrgUnitId];
+          const parent = map.get(item.parentOrgUnitId);
           parent.orgChildrenList.push(node);
-          parent.children.push(node); // 同步 children 字段
-          parent.leafNode = false;
-          parent.expand = true;
+          parent.children.push(node);
+          parent.leafNode = false; // 有子节点则强制非叶子节点
+          parent.expand = true; // 有子节点则强制展开
         }
       });
+
+      if (roots.length === 0 && map.size > 0) {
+        roots.push(Array.from(map.values())[0]);
+      }
+
       return roots;
     },
 
@@ -691,7 +966,7 @@ export default {
       this.staffEnding = false;
       this.offset = 0;
       this.staffAllList = [];
-      // 关键修复：50ms延迟，解决极端情况下的异步更新问题
+      // 50ms延迟，解决极端情况下的异步更新问题
       setTimeout(() => {
         this.loadMore();
       }, 50);
@@ -806,7 +1081,7 @@ export default {
         return;
       }
 
-      // 关键修复1：过滤仅含有效orgUnitId的节点，排除无效数据
+      // 过滤仅含有效orgUnitId的节点，排除无效数据
       const validNodes = data.filter(node =>
           node.orgUnitId && typeof node.orgUnitId === 'string' // 确保orgUnitId存在且为字符串
       );
@@ -820,7 +1095,7 @@ export default {
         return;
       }
 
-      // 关键修复2：单选逻辑强化，仅保留最后一个有效选中节点
+      // 单选逻辑强化，仅保留最后一个有效选中节点
       const currentNode = validNodes[validNodes.length - 1];
       const currentOrgUnitId = currentNode.orgUnitId.trim(); // 去除空格，避免无效字符串
 
@@ -835,11 +1110,11 @@ export default {
       if (pureNode.orgChildrenList) pureNode.orgChildrenList = [];
       if (pureNode.children) pureNode.children = [];
 
-      // 关键修复3：强制响应式更新，避免Vue数据延迟
+      // 强制响应式更新，避免Vue数据延迟
       this.$set(this, 'proStaffOrgList', [pureNode]);
       this.$set(this, 'selectedStaffOrgId', currentOrgUnitId);
 
-      // 关键修复4：双重nextTick确保数据完全更新后再查询
+      // 双重nextTick确保数据完全更新后再查询
       this.$nextTick(() => {
         if (this.selectedStaffOrgId !== currentOrgUnitId) {
           this.$set(this, 'selectedStaffOrgId', currentOrgUnitId);
@@ -1049,15 +1324,14 @@ export default {
         this.offset = 0;
         this.staffAllList = [];
         this.loadingStaff = false;
-        this.loadMore().catch(err => console.log("同步加载失败：", err));
-        this.$nextTick(() => {
-          setTimeout(() => {
-            this.loadMore();
-          }, 100);
-        });
-      } else if (tabName === 'post' && this.$refs.postTree && this.proPostList.length === 0) {
+        // 仅当树未初始化时才加载
+        if (!this.staffTreeLoaded || this.staffTree.length === 0) {
+          this.loadMore().catch(err => console.log("同步加载失败：", err));
+        }
+      } else if (tabName === 'post' && this.proPostList.length === 0) {
         this.proPostList = [];
-        this.$refs.postTree.initData();
+        // 移除initData调用，避免重置树数据
+        // this.$refs.postTree.initData();
       }
     },
     initStaffList() {
@@ -1081,7 +1355,8 @@ export default {
       const proListKey = 'proOrgList';
       const treeDataKey = 'orgTree';
       this[proListKey] = [];
-      if (treeRef) await treeRef.initData();
+      // 移除initData调用
+      // if (treeRef) await treeRef.initData();
       if (!treeRef) {
         this.$Message.error("组织树组件未初始化，请稍后再试");
         item.checked = !item.checked;
@@ -1125,7 +1400,8 @@ export default {
 
       this[proListKey] = [];
       const isCurrentlyChecked = item.checked;
-      if (treeRef) await treeRef.initData();
+      // 移除initData调用，避免重置树数据
+      // if (treeRef) await treeRef.initData();
 
       // 2. 清空岗位 Tab 标签选中状态（仅操作 postTagList）
       this.postTagList.forEach(tag => {
@@ -1322,7 +1598,6 @@ export default {
                 }
               }
 
-              // 最终数据赋值（根据Tab类型区分，核心统一逻辑）
 
               if (matchedNodes.length > 0) {
                 // 同步暂存列表（组织proOrgList/岗位proPostList）
@@ -1417,7 +1692,6 @@ export default {
         return obj;
       }
 
-      // 检测到循环引用时，保留核心字段（orgUnitId必选，其他字段尽可能保留）
       if (hash.has(obj)) {
         const safeObj = {
           orgUnitId: obj.orgUnitId,
@@ -1535,7 +1809,7 @@ export default {
               if (res.data.code === 1 && res.data.data && res.data.data.orgUnitId) {
                 // 深拷贝并清理无效字段
                 const node = this.safeDeepCopy(res.data.data);
-                // 核心修复：确保节点名称有默认值，避免空显示
+                // 确保节点名称有默认值，避免空显示
                 const nodeName = node.orgNodeName || node.orgUnitName || node.name || `未命名组织(${orgUnitId})`;
                 node.orgNodeName = nodeName;
                 node.orgUnitName = nodeName; // 同步更新orgUnitName，确保所有使用场景都有值
@@ -1661,29 +1935,59 @@ export default {
 
 .staff-left-right-layout {
   display: flex;
-  height: 650px !important;
+  // 适配全屏：使用视口高度百分比 + 最小高度限制
+  height: calc(100vh - 180px) !important;
+  min-height: 500px !important;
   gap: 15px;
   padding: 0 5px;
   width: 100%;
   box-sizing: border-box;
   flex-wrap: nowrap !important;
 
+  // 小屏幕 不改变左右结构
+  @media (max-width: 1200px) {
+    height: calc(100vh - 200px) !important;
+
+    & > .staff-left-panel {
+      width: calc(60% - 7.5px) !important;
+      min-width: 280px !important;
+      max-width: none !important;
+    }
+  }
+
+  @media (max-width: 768px) {
+    flex-wrap: wrap !important;
+
+    & > .staff-left-panel {
+      width: 100% !important;
+      min-width: 100% !important;
+      max-width: 100% !important;
+      height: 40% !important;
+      margin-bottom: 10px;
+    }
+
+    .staff-right-panel {
+      width: 100% !important;
+      height: 60% !important;
+    }
+  }
+
   & > .staff-left-panel {
-    width: 320px !important;
+    width: calc(60% - 7.5px) !important;
     min-width: 320px !important;
-    max-width: 320px !important;
+    max-width: none !important;
     display: flex !important;
     flex-direction: column !important;
     box-sizing: border-box !important;
     flex-shrink: 0 !important;
     flex-grow: 0 !important;
     height: 100% !important;
-    position: relative !important; // 确保子元素 z-index 生效
+    position: relative !important;
 
     ::v-deep(.panel-title) {
       all: unset !important;
-      display: flex !important; // 改为flex，方便对齐竖条和文字
-      align-items: center !important; // 文字垂直居中
+      display: flex !important;
+      align-items: center !important;
       visibility: visible !important;
       opacity: 1 !important;
       height: 20px !important;
@@ -1698,20 +2002,20 @@ export default {
       box-sizing: border-box !important;
       position: relative !important;
       width: 100% !important;
-      // 左侧竖条核心样式
+      // 左侧竖条样式
       &::before {
         content: '' !important;
         display: inline-block !important;
         width: 5px !important; // 竖条宽度
         height: 16px !important; // 竖条高度（略小于文字行高）
-        background-color: #1890ff !important; // 蓝色竖条（可改颜色）
+        background-color: #1890ff !important; // 蓝色竖条
         margin-right: 8px !important; // 竖条与文字间距
         //border-radius: 1.5px !important;
       }
     }
 
     .staff-org-tree {
-      height: calc(100% - 28px) !important; /* 28 = 标题高度20 + 间距8 */
+      height: calc(100% - 28px - 10px) !important; /* 28=标题高度+间距 + 10px额外缩减，确保按钮可见 */
       border: 1px solid #EAECF0;
       border-radius: 4px;
       padding: 0 !important;
@@ -1748,9 +2052,8 @@ export default {
   }
 
   .staff-right-panel {
-    flex: 1 !important;
+    width: calc(40% - 7.5px) !important;
     min-width: 0 !important;
-    width: calc(100% - 335px) !important;
     display: flex;
     flex-direction: column;
     box-sizing: border-box;
@@ -1764,9 +2067,10 @@ export default {
       flex-shrink: 0;
     }
 
-    // 右侧人员列表容器：高度 = 父容器高度 - 搜索框高度 - 底部选择栏高度 - 两次间距(8*2)
+    // 右侧人员列表容器：适配全屏高度
     .staff-content {
-      height: calc(100% - 32px - 40px - 16px) !important; /* 40=底部选择栏高度，16=8*2间距 */
+      height: calc(100% - 32px - 40px - 16px - 10px) !important;
+      min-height: 200px !important; // 小屏幕最小高度限制
       border: 1px solid #EAECF0;
       border-radius: 4px;
       overflow-x: hidden !important;
@@ -1804,11 +2108,21 @@ export default {
   }
 }
 
+
 .tab-content-pro {
   .tab {
+    .search-row {
+      display: flex;
+      align-items: center;
+      flex-wrap: nowrap; // 禁止换行
+      width: 100%;
+      gap: 8px; // 文字和搜索框之间的间距
+    }
     .tree {
-      height: 500px !important;
-      max-height: 500px !important;
+      // 全屏 使用百分比高度 + 最小高度
+      height: calc(100vh - 340px) !important; // 从300px增加到340px，缩减40px高度
+      min-height: 360px !important; // 降低最小高度，确保按钮可见
+      max-height: none !important; // 移除最大高度限制
       margin-top:20px;
       overflow-y: auto !important;
       overflow-x: auto !important;
@@ -1829,8 +2143,10 @@ export default {
     }
 
     &.post .right .tree {
-      height: 380px !important;
-      max-height: 380px !important;
+      // 岗位树适配全屏（缩减高度确保按钮可见）
+      height: calc(100vh - 430px) !important; // 从400px增加到430px，缩减30px高度
+      min-height: 270px !important; // 降低最小高度，确保按钮可见
+      max-height: none !important;
     }
 
     .bottom-select {
@@ -1847,10 +2163,21 @@ export default {
         color:var(--primary-color);
       }
     }
+    // 搜索标签样式（固定宽度，不换行）
+    .search-label {
+      white-space: nowrap; // 文字不换行
+      flex-shrink: 0; // 不被压缩
+      font-size: 14px;
+      color: #333;
+    }
+    // 搜索框容器样式（自适应剩余宽度）
+    .search-input-wrapper {
+      flex: 1; // 占满剩余宽度
+      min-width: 0; // 允许搜索框收缩
+    }
   }
 }
 
-
 /deep/ .ivu-tree {
   width: 100% !important;
   box-sizing: border-box;
@@ -1893,11 +2220,24 @@ export default {
 }
 
 .tab.post .left {
-  width: 200px;
-  height: 450px !important;
+  width: calc(50% - 10px) !important;
+  // 适配全屏高度
+  height: calc(100vh - 380px) !important;
+  min-height: 270px !important;
   overflow: hidden !important;
   padding-right: 10px;
   box-sizing: border-box;
+
+  // 小屏幕仅调整宽度，不改变左右结构
+  @media (max-width: 1200px) {
+    width: calc(50% - 10px) !important;
+  }
+
+  // 超小屏幕
+  @media (max-width: 768px) {
+    width: 100%;
+    margin-bottom: 10px;
+  }
 }
 
 .scroll-container {
@@ -2010,6 +2350,12 @@ export default {
 }
 
 .modal-tree{
+  // 全屏适配：移除固定宽度限制
+  width: 100% !important;
+  height: 100% !important;
+  max-width: none !important;
+  max-height: none !important;
+
   .header-text{
     font-weight: bold;
     font-size: 16px;
@@ -2024,12 +2370,20 @@ export default {
     line-height: 16px;
   }
   .content-container{
+    width: 100%;
+    height: 100%;
+    padding: 10px;
+    box-sizing: border-box;
   }
   .tree-orig{
     width:100%;
     display: flex;
-    height: 700px;
+    // 适配全屏高度
+    height: calc(100vh - 80px) !important;
+    min-height: 600px !important;
     background: #fff;
+    // 强制保留左右结构，仅超小屏幕 换行
+    flex-wrap: nowrap !important;
 
     :global(.ivu-tabs-ink-bar) {
       height: 0 !important;
@@ -2072,9 +2426,22 @@ export default {
       }
     }
     .tab-content-pro{
-      width: 720px;
+      // 6:4比例 - 减去gap的一半
+      width: calc(60% - 10px) !important;
+      max-width: none !important; // 取消固定最大宽度，按比例适配
+      flex-shrink: 0 !important; // 禁止压缩
       border-radius: 8px;
       border: 1px solid #EAECF0;
+      // 小屏幕保持6:4比例
+      @media (max-width: 1200px) {
+        width: calc(60% - 10px) !important;
+      }
+      // 超小屏幕兜底
+      @media (max-width: 768px) {
+        width: 100% !important;
+        margin-bottom: 10px;
+      }
+
       .tab{
         padding:20px;
         .tag-content{
@@ -2084,12 +2451,13 @@ export default {
           align-items: center;
         }
         .tree {
-          height: 500px !important; // 从450px下调，预留下方复选框空间
-          max-height: 500px !important; // 强制最大高度，禁止超出
+          height: calc(100vh - 340px) !important; // 缩减40px确保按钮可见
+          min-height: 360px !important; // 降低最小高度
+          max-height: none !important; // 移除最大高度限制
           margin-top:20px;
           overflow-y: auto !important; // 纵向溢出时滚动，而非超出
           overflow-x: auto !important; // 横向溢出时滚动
-          border: 1px solid #EAECF0; // 明确容器边界（可选）
+          border: 1px solid #EAECF0; // 明确容器边界
           border-radius: 4px;
           box-sizing: border-box; // 包含边框/内边距计算
           // 滚动条样式统一（与人员Tab保持一致）
@@ -2105,8 +2473,9 @@ export default {
           }
         }
         &.post .right .tree {
-          height: 380px !important;
-          max-height: 380px !important;
+          height: calc(100vh - 430px) !important; // 缩减30px确保按钮可见
+          min-height: 270px !important; // 降低最小高度
+          max-height: none !important;
         }
         .staff-content{
           overflow:auto;
@@ -2120,7 +2489,7 @@ export default {
           background: #fff !important; // 白色背景覆盖树溢出内容
           position: relative;
           z-index: 10; // 层级高于树容器
-          border-top: 1px solid #f0f0f0; // 视觉分隔（可选）
+          border-top: 1px solid #f0f0f0; // 视觉分隔
           .num{
             color:var(--primary-color);
           }
@@ -2163,8 +2532,29 @@ export default {
       .post{
         display: flex;
         height: 100%;
+        // 小屏幕仅调整宽度，不改变左右结构
+        @media (max-width: 1200px) {
+          .left {
+            width: calc(50% - 10px) !important; // 同步改为50%
+          }
+        }
+        // 超小屏幕兜底
+        @media (max-width: 768px) {
+          flex-direction: column;
+
+          .left {
+            width: 100%;
+            margin-bottom: 10px;
+          }
+
+          .right {
+            margin-left: 0;
+            width: 100%;
+          }
+        }
+
         .left{
-          width:200px;
+          width: calc(50% - 10px) !important;
           overflow: auto;
           >div{
             background: #FFFFFF;
@@ -2185,7 +2575,8 @@ export default {
         }
         .right{
           margin-left:20px;
-          flex: 1;
+          width: calc(50% - 10px) !important;
+          flex: none !important;
         }
       }
       .gust-item{
@@ -2235,12 +2626,23 @@ export default {
       //}
     }
     .form-content{
-      flex:1;
+      // 6:4比例 - 减去gap的一半
+      width: calc(40% - 10px) !important;
+      min-width: 300px !important; // 最小宽度限制
       overflow: hidden;
       border-radius: 8px;
       border: 1px solid #EAECF0;
       margin-left:20px;
       padding:10px 20px;
+      height: 100%;
+      flex: none !important; // 取消弹性，固定比例
+      // 超小屏幕
+      @media (max-width: 768px) {
+        margin-left: 0;
+        width: 100%;
+        margin-top: 10px;
+      }
+
       >p{
         font-weight: 500;
         font-size: 16px;
@@ -2300,4 +2702,28 @@ export default {
     }
   }
 }
+
+// 超小屏幕适配（手机端）
+@media (max-width: 768px) {
+  .modal-tree .tree-orig {
+    flex-wrap: wrap !important; // 仅超小屏幕换行
+    height: calc(100vh - 100px) !important;
+    min-height: 400px !important;
+  }
+
+  .tab-content-pro .tab .tree {
+    height: calc(100vh - 380px) !important;
+    min-height: 300px !important;
+  }
+
+  .tab.post .left {
+    height: calc(100vh - 480px) !important;
+    min-height: 200px !important;
+  }
+
+  .staff-left-right-layout {
+    height: calc(100vh - 220px) !important;
+    min-height: 400px !important;
+  }
+}
 </style>