@sy-common/organize-select-help 1.0.0-beta.54 → 1.0.0-beta.56

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sy-common/organize-select-help",
-  "version": "1.0.0-beta.54",
+  "version": "1.0.0-beta.56",
   "description": "",
   "main": "index.js",
   "author": "lambo",

package/src/index.vue

@@ -135,6 +135,9 @@
                           :checkStrictly="true"
                           :autoExpandParent="true"
                           :isSingleSelect="true"
+                          :default-org-unit-id="defaultOrgUnitId"
+                          :is-custom-tree="!!defaultOrgUnitId"
+                          :disable-lazy-load="false"
                       ></organizeTree>
                     </div>
                   </div>
@@ -294,15 +297,19 @@ export default {
       staffOrgList:[],
       staffSearchList:[],
       selectedStaffOrgId: '', // 新增：选中的组织节点ID
-      proStaffOrgList: [] // 新增：暂存选中的组织节点
+      proStaffOrgList: [], // 新增：暂存选中的组织节点
+      initialDefaultOrgUnitId: '', // 缓存初始defaultOrgUnitId
+      staffTreeInited: false, // 组织树初始化完成标记（用于需求3）
     }
   },
   mounted() {
     this.queryTagList()
     this.queryPositionList()
     // this.loadMore()
+    this.initialDefaultOrgUnitId = this.defaultOrgUnitId || ''; // 缓存初始值
     this.initStaffOrgTree()
   },
+
   methods:{
     async initStaffOrgTree() {
       try {
@@ -312,18 +319,44 @@ export default {
 
         const rootOrgId = this.defaultOrgUnitId || '';
         let rootNode = null;
+        let treeSourceData = []; // 存储树原始数据，避免后续覆盖
 
         if (rootOrgId) {
-          const leafNode = await this.judgeNodeLeafe(rootOrgId);
-          const orgDetail = await this.queryOrgNodeDetail(rootOrgId);
-          rootNode = this.safeDeepCopy({
-            ...orgDetail,
-            orgNodeName: orgDetail.orgNodeName || orgDetail.name,
-            leafNode,
-            expand: true,
-            parentOrgUnitId: orgDetail.parentOrgUnitId || orgDetail.parentId
+          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 }
           });
@@ -332,19 +365,17 @@ export default {
             if (rootNode) {
               rootNode.expand = true;
               rootNode.parentOrgUnitId = rootNode.parentId;
+              treeSourceData = [rootNode];
             }
           }
         }
 
-        if (rootNode) {
-          let parentsList = await this.getParentOrgNodesByOrgUnitId(rootNode.orgUnitId);
-          const safeParents = this.safeDeepCopy(parentsList);
-          safeParents.forEach(node => {
-            node.expand = true;
-            node.parentOrgUnitId = node.parentId;
-          });
-          const tree = this.buildTree([...safeParents, rootNode]);
+        // 构建组织树，且仅赋值一次，避免后续覆盖（需求3）
+        if (treeSourceData.length > 0) {
+          const tree = this.buildTree(treeSourceData);
           this.staffTree = this.safeDeepCopy(tree);
+          // 关键：标记树已初始化完成，防止后续重复构建覆盖
+          this.staffTreeInited = true;
         }
       } catch (e) {
         this.$Message.error("人员选择组织树初始化失败！");
@@ -628,14 +659,15 @@ export default {
     buildTree(items) {
       const map = {};
       const roots = [];
-      // 对输入数据进行安全拷贝
       const copiedItems = this.safeDeepCopy(items);
 
       copiedItems.forEach(item => {
-        if (!item.orgUnitId) return; // 过滤无效节点
+        if (!item.orgUnitId) return;
         map[item.orgUnitId] = this.safeDeepCopy({
           ...item,
-          orgChildrenList: []
+          orgChildrenList: [],
+          children: [], // 强制初始化 children 空数组
+          title: item.orgUnitName || item.orgNodeName || item.name || `未命名组织(${item.orgUnitId || ''})`
         });
       });
 
@@ -648,6 +680,9 @@ export default {
         } else {
           const parent = map[item.parentOrgUnitId];
           parent.orgChildrenList.push(node);
+          parent.children.push(node); // 同步 children 字段
+          parent.leafNode = false;
+          parent.expand = true;
         }
       });
       return roots;
@@ -669,15 +704,15 @@ export default {
         limit: 10
       };
 
-      // 关键优化：实时监测选中状态，未选中时显式传递空字符串（而非不传递）
       if (this.selectedStaffOrgId && typeof this.selectedStaffOrgId === 'string' && this.selectedStaffOrgId.trim()) {
         params.orgUnitId = this.selectedStaffOrgId.trim();
+      } else if (this.initialDefaultOrgUnitId && this.initialDefaultOrgUnitId.trim()) {
+        // 初始化及未选中节点时，使用传入的defaultOrgUnitId
+        params.orgUnitId = this.initialDefaultOrgUnitId.trim();
       } else {
-        // 未选中任何节点时，显式设置orgUnitId为空字符串
         params.orgUnitId = '';
       }
 
-      // 调试日志：查看最终传递的参数
       console.log('人员查询接口参数:', params);
 
       return new Promise((resolve, reject) => {
@@ -722,9 +757,8 @@ export default {
       }
     },
     getOrgList(data) {
-      // 过滤有效节点：仅要求orgUnitId（orgNodeName可选，用默认值兜底）
       const validNodes = Array.isArray(data)
-          ? data.filter(node => node.orgUnitId) // 仅校验orgUnitId（必选）
+          ? data.filter(node => node.orgUnitId)
           : [];
 
       // 去重：基于orgUnitId避免重复
@@ -732,14 +766,13 @@ export default {
           self.findIndex(item => item.orgUnitId === node.orgUnitId) === index
       );
 
-      // 补全缺失字段，避免后续处理报错
+
       const completeNodes = uniqueNodes.map(node => ({
         ...node,
         orgNodeName: node.orgNodeName || node.name || `未命名组织(${node.orgUnitId})`,
         orgUnitName: node.orgNodeName || node.name || `未命名组织(${node.orgUnitId})`
       }));
 
-      // 安全深拷贝，确保数据响应式
       this.proOrgList = this.safeDeepCopy(completeNodes);
     },
 
@@ -974,9 +1007,6 @@ export default {
       if (this.$refs.staffTree) {
         this.$refs.staffTree.clearAllChecked(this.$refs.staffTree.data);
         this.$refs.staffTree.$emit('handleChange', []);
-        if (this.$refs.staffTree.initData) {
-          this.$refs.staffTree.initData();
-        }
       }
       if (this.tabName === 'staff') {
         this.$nextTick(() => {
@@ -984,43 +1014,38 @@ export default {
         });
       }
     },
-    initStaffList() {
-      this.staffEnding = false;
-      this.offset = 0;
-      this.staffAllList = [];
-      // 小幅延迟，确保树重置完成后再发起查询（避免时序差）
-      this.$nextTick(() => {
-        setTimeout(() => {
-          this.loadMore();
-        }, 50); // 50ms足够，可根据实际情况调整
-      });
-    },
-    // 处理Tab切换，同步更新tabName
+
     handleTabChange(tabName) {
       this.tabName = tabName;
 
-      // 仅修改人员Tab相关逻辑，不影响其他Tab
       if (tabName === 'staff') {
         this.resetStaffTreeChecked();
-        // 第一步：同步重置查询参数（确保参数干净）
         this.staffEnding = false;
         this.offset = 0;
         this.staffAllList = [];
-        this.loadingStaff = false; // 强制解除加载中状态
-        // 第二步：立即同步调用（优先执行）
+        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) {
-        // 保留原有岗位Tab逻辑，不修改
         this.proPostList = [];
         this.$refs.postTree.initData();
       }
     },
+    initStaffList() {
+      this.staffEnding = false;
+      this.offset = 0;
+      this.staffAllList = [];
+      // 小幅延迟，确保树重置完成后再发起查询（避免时序差）
+      this.$nextTick(() => {
+        setTimeout(() => {
+          this.loadMore();
+        }, 50); // 50ms足够，可根据实际情况调整
+      });
+    },
     async fastChedkOrg(item) {
       // 1. 改用组织 Tab 专属标签列表判断
       if (!this.orgTagList.length) {

package/src/organize-tree.vue

@@ -33,6 +33,21 @@ export default {
     isSingleSelect: {
       type: Boolean,
       default: false
+    },
+    // 新增1：接收父组件的 defaultOrgUnitId（自定义根节点ID）
+    defaultOrgUnitId: {
+      type: String,
+      default: ''
+    },
+    // 新增2：标记是否使用父组件构建的自定义树（禁用子组件自身的接口调用）
+    isCustomTree: {
+      type: Boolean,
+      default: false
+    },
+    // 新增3：禁用懒加载（避免触发子组件的旧接口）
+    disableLazyLoad: {
+      type: Boolean,
+      default: false
     }
   },
   data() {
@@ -46,13 +61,66 @@ export default {
     this.initData();
   },
   methods: {
+    safeDeepCopy(obj, hash = new WeakMap()) {
+      if (obj === null || typeof obj !== 'object') {
+        return obj;
+      }
+
+      // 检测循环引用，返回核心业务字段
+      if (hash.has(obj)) {
+        const safeObj = {
+          orgUnitId: obj.orgUnitId,
+          orgNodeName: obj.orgNodeName || obj.name || `未命名组织(${obj.orgUnitId || 'unknown'})`,
+          orgUnitName: obj.orgUnitName || obj.orgNodeName || obj.name || `未命名组织(${obj.orgUnitId || 'unknown'})`,
+          parentOrgUnitId: obj.parentOrgUnitId || obj.parentId || null
+        };
+        hash.set(obj, safeObj);
+        return safeObj;
+      }
+
+      let copy;
+      if (obj instanceof Array) {
+        copy = [];
+        hash.set(obj, copy);
+        for (let i = 0; i < obj.length; i++) {
+          copy[i] = this.safeDeepCopy(obj[i], hash);
+        }
+      } else if (obj instanceof Object) {
+        copy = {};
+        hash.set(obj, copy);
+        for (let key in obj) {
+          if (obj.hasOwnProperty(key)) {
+            // 过滤Vue内部无效字段，保留业务字段
+            if (['__vue__', '__ob__', '$parent', '$children'].includes(key)) {
+              continue;
+            }
+            // 子节点数组特殊处理
+            if (['orgChildrenList', 'children'].includes(key) && Array.isArray(obj[key])) {
+              copy[key] = obj[key].map(child => this.safeDeepCopy(child, hash));
+            } else {
+              copy[key] = this.safeDeepCopy(obj[key], hash);
+            }
+          }
+        }
+      } else {
+        copy = obj;
+      }
+      return copy;
+    },
     async initData() {
+      if (this.isCustomTree) {
+        this.loading = false;
+        let tree = deepCopy(this.treeList);
+        this.initTree(tree);
+        this.data = tree;
+        return;
+      }
+      // 仅在非自定义树场景下生效
       let data = await this.getOrgChildren();
       this.loading = false;
       this.data = data;
     },
 
-    // 树组件内的 handleChange 方法修改（仅保留核心逻辑，移除冗余触发）
     handleChange(data) {
       // 仅处理复选框触发的选中数据，过滤空数据
       if (!data || (Array.isArray(data) && data.length === 0)) {
@@ -105,18 +173,73 @@ export default {
           if (node.checked !== shouldBeChecked) {
             this.$set(node, 'checked', shouldBeChecked);
           }
-          // 彻底删除子节点递归逻辑
         });
       };
       updateNodeState(this.data);
     },
 
     async loadData(item, callback) {
+      // 自定义树场景（defaultOrgUnitId 不为空）：原有逻辑不变
+      if (this.isCustomTree) {
+        let children = item.orgChildrenList || item.children || [];
+        const formattedChildren = this.safeDeepCopy(children).map(child => ({
+          ...child,
+          title: child.orgUnitName || child.orgNodeName || child.name || `未命名组织(${child.orgUnitId || child.id || ''})`,
+          checked: false,
+          expand: false,
+          leafNode: child.leafNode || false,
+          orgChildrenList: child.orgChildrenList || [],
+          children: child.children || []
+        }));
+        if (formattedChildren.length === 0 && item.orgUnitId) {
+          try {
+            const res = await ajax.get('/pub-manage-server/pub/personHelpBox/q/getOrgUnitList', {
+              params: {
+                containsCurLevel: true,
+                orgUnitId: item.orgUnitId
+              }
+            });
+            if (res.data.code === 1) {
+              const apiChildren = res.data.data || [];
+              // 关键：对接口返回的二级节点进行 initTree 初始化
+              const initializedApiChildren = this.initTree(apiChildren);
+              const apiFormattedChildren = initializedApiChildren.map(child => ({
+                ...child,
+                title: child.orgUnitName || child.orgNodeName || child.name || `未命名组织(${child.orgUnitId || ''})`,
+                checked: false,
+                expand: false,
+                leafNode: child.leafNode || false,
+                orgChildrenList: [],
+                children: []
+              }));
+              item.orgChildrenList = apiFormattedChildren;
+              item.children = apiFormattedChildren;
+              callback(apiFormattedChildren);
+              return;
+            }
+          } catch (e) {
+            console.error("加载自定义树子节点失败：", e);
+          }
+        }
+        callback(formattedChildren);
+        return;
+      }
+
+      // 非自定义树场景（defaultOrgUnitId 为空）：补充子节点初始化
+      if (this.disableLazyLoad) {
+        callback([]);
+        return;
+      }
+      // 加载子节点后，先经过 initTree 处理再返回
       let children = await this.getOrgChildren(item.orgUnitId);
-      callback(children);
+      const initializedChildren = this.initTree(children);
+      callback(initializedChildren);
     },
 
     getOrgChildren(orgUnitId = '') {
+      if (this.isCustomTree) {
+        return Promise.resolve([]);
+      }
       return new Promise((resolve, reject) => {
         ajax.get('/pub-manage-server/pub/personHelpBox/q/getOrgUnitList', {
           params: {
@@ -125,9 +248,10 @@ export default {
           }
         }).then((res) => {
           if (res.data.code === 1) {
-            let treeList = res.data.data;
-            this.initTree(treeList);
-            resolve(treeList);
+            let treeList = res.data.data || [];
+            // 关键修改：调用重构后的 initTree，递归初始化所有层级节点
+            const initializedTree = this.initTree(treeList);
+            resolve(initializedTree);
           } else {
             resolve([]);
           }
@@ -253,61 +377,58 @@ export default {
       }
       return null;
     },
-
+    // organize-tree.vue - 重构 initTree 方法，确保递归处理所有层级
     initTree(treeList) {
-      const defineTree = function (list) {
-        if (!list) return;
-        list.forEach((item) => {
-          item.title = item.orgNodeName;
-          item.loading = false;
-          item.children = [];
-          item.expand = false;
-          item.checked = false; // 确保checked属性初始化
-          if (item.leafNode) {
-            delete item.loading;
-            delete item.children;
-          }
-          if (item.orgChildrenList && item.orgChildrenList.length) {
-            item.children = defineTree(item.orgChildrenList);
-            item.expand = true;
-          }
-        });
-        return list;
-      };
-      treeList.forEach(item => {
-        item.title = item.orgNodeName;
-        item.loading = false;
-        item.children = [];
-        item.expand = false;
-        item.checked = false; // 初始化Checkbox绑定的checked属性
-        if (item.orgChildrenList && item.orgChildrenList.length) {
-          item.children = defineTree(item.orgChildrenList);
-          item.expand = true;
-        }
+      // 递归处理节点的内部方法
+      const recursiveInitNode = (node) => {
+        // 1. 统一节点标题（优先级：orgUnitName > orgNodeName > name > 兜底）
+        node.title = node.orgUnitName || node.orgNodeName || node.name || `未命名组织(${node.orgUnitId || node.id || ''})`;
+        // 2. 初始化基础字段
+        node.loading = false;
+        node.expand = false;
+        node.checked = false;
+        // 3. 关键：无论是否有子节点，先初始化 children 空数组（让 Tree 组件识别可懒加载）
+        node.children = node.children || [];
+        // 4. 同步 orgChildrenList 和 children（双向绑定，避免字段不一致）
+        node.orgChildrenList = node.orgChildrenList || node.children || [];
+        // 5. 禁用状态处理
         if (this.disabled) {
-          item.disabled = true;
+          node.disabled = true;
         }
-        if (item.leafNode) {
-          delete item.loading;
-          delete item.children;
+        // 6. 叶子节点判断：如果明确标记为 leafNode，删除 loading 和 children（禁止展开）
+        if (node.leafNode) {
+          delete node.loading;
+          delete node.children;
+          delete node.orgChildrenList;
+        } else {
+          // 7. 非叶子节点：递归处理已有子节点（确保下级节点也完成初始化）
+          if (Array.isArray(node.orgChildrenList) && node.orgChildrenList.length > 0) {
+            node.children = node.orgChildrenList.map(child => recursiveInitNode(child));
+            node.expand = true; // 默认展开已有子节点的节点
+          }
         }
-      });
+        return node;
+      };
+
+      // 处理根节点列表
+      if (Array.isArray(treeList)) {
+        return treeList.map(node => recursiveInitNode(node));
+      }
+      return treeList;
     },
 
-    //renderContent添加Checkbox组件
     renderContent(h, {root, node, data}) {
+      const nodeText = data.orgUnitName || data.title || data.orgNodeName || data.name || `未命名组织(${data.orgUnitId || data.id || ''})`;
       return h('div', {
         style: {
           width: '100%',
           overflow: 'hidden',
           display: 'flex',
           alignItems: 'center',
-          cursor: 'default' // 文本区域鼠标指针改为默认
+          cursor: 'default'
         },
-        // 阻断整个节点容器的点击事件（仅复选框除外）
         on: {
           click: (e) => {
-            // 仅当点击复选框时放行，其他区域阻断
             const isCheckbox = e.target.closest('.ivu-checkbox') || e.target.closest('.ivu-checkbox-icon');
             if (!isCheckbox) {
               e.stopPropagation();
@@ -324,22 +445,17 @@ export default {
           },
           style: {
             marginRight: '8px',
-            cursor: 'pointer' // 复选框保留点击指针
+            cursor: 'pointer'
           },
           on: {
             'on-change': (checked) => {
               this.$set(data, 'checked', checked);
-
-              // 单选逻辑：勾选当前节点时，清空其他所有节点
               if (this.isSingleSelect && checked) {
                 this.clearOtherCheckedNodes([data.orgUnitId]);
               }
-
-              // 收集选中节点（单选时仅返回当前节点）
               const checkedNodes = this.isSingleSelect
                   ? (checked ? [data] : [])
                   : this.collectCurrentCheckedNodes(this.data);
-
               this.handleChange(checkedNodes);
             }
           }
@@ -350,18 +466,19 @@ export default {
             marginRight: '8px',
             width: '14px',
             height: '14px',
-            pointerEvents: 'none' // 图标禁用点击
+            pointerEvents: 'none'
           }
         }),
         h('span', {
           style: {
-            // overflow: 'hidden',
-            // textOverflow: 'ellipsis',
             flex: 1,
-            pointerEvents: 'none', // 文本完全禁用点击
-            userSelect: 'none' // 禁止文本选中
+            pointerEvents: 'none',
+            userSelect: 'none',
+            // 新增：防止文字溢出导致的截断（可选，解决orgUnitId显示不全问题）
+            whiteSpace: 'normal',
+            wordWrap: 'break-word'
           }
-        }, data.title)
+        }, nodeText) // 使用调整优先级后的节点文字
       ]);
     },
     collectCurrentCheckedNodes(nodeList) {
@@ -399,6 +516,14 @@ export default {
   watch: {
     'treeList': {
       handler(val) {
+        // 自定义树场景：直接使用父组件传递的树数据，不初始化旧接口
+        if (this.isCustomTree) {
+          let tree = deepCopy(val);
+          this.initTree(tree);
+          this.data = tree;
+          return;
+        }
+        // 原有逻辑
         let tree = deepCopy(val);
         this.initTree(tree);
         this.data = tree;