centaline-data-driven-v3 0.1.40 → 0.1.42

package/src/components/web/Tree/Tree.vue

@@ -1,19 +1,23 @@
 <template>
   <div id="ct-tree" class="ct-tree" oncontextmenu="event.preventDefault()" style="overflow:auto;" v-loading="loading"
     :style="{ height: props.treeHeight - 10 + 'px' }">
-    <el-tree class="tree-line" :props="defaultProps" :load="loadNode" :expand-on-click-node="false"
-      @node-click="handleNodeClick" lazy ref="refTree" @node-contextmenu="rightClick" node-key="code"
-      current-node-key="currentNodeKey">
-
+    <el-tree class="tree-line" :props="defaultProps" :expand-on-click-node="false" @node-click="handleNodeClick"
+      :filter-node-method="filterNode" lazy :load="loadNode" ref="refTree" @node-contextmenu="rightClick"
+      node-key="code" current-node-key="currentNodeKey" :default-expanded-keys="defaultExpandedKeys">
       <template #default="{ node, data }">
-        <span>
-          <span style="margin-left: 10px" :ref="(el: refItem) => handleSetInputMap(el, data)">{{
+        <span class="node_content">
+          <el-icon class="node-icon" :class="{ 'is-leaf': node.isLeaf }">
+            <Document v-if="node.isLeaf" :size="14" />
+            <Folder v-else-if="!node.expanded" :size="14" />
+            <FolderOpened v-else :size="14" />
+          </el-icon>
+          <span style="" :ref="(el: refItem) => handleSetInputMap(el, data)">{{
             data.name }}</span>
           <span @click.stop>
             <el-popover placement="right" :virtual-ref="nodeRef" virtual-triggering
-              :visible="((data.code == currentData.code && menuVisible && model.actionRouter?.length > 0))">
+              :visible="((data.code == currentData.code && menuVisible && allowedRoutes?.length > 0))">
               <div class="box-menu">
-                <template v-for="(item, index) in model.actionRouter">
+                <template v-for="(item, index) in allowedRoutes">
                   <div class="opertion" @click="routerClickHandler(item)">
                     <div>
                       <img v-if="item.imgUrl" :src="item.imgUrl" alt="" />
@@ -22,22 +26,21 @@
                   </div>
                 </template>
               </div>
-
             </el-popover>
           </span>
         </span>
       </template>
     </el-tree>
-
-
   </div>
 </template>
+
 <script setup lang="ts">
-import { ref, nextTick, ComponentPublicInstance, onBeforeUnmount } from 'vue'
+import { ref, nextTick, ComponentPublicInstance, onBeforeUnmount, computed, watch } from 'vue'
 import common from '../../../utils/common'
 import { RouterClickHandler } from '../../../utils/mixins';
 import Enum from '../../../utils/Enum'
 import Tree from '../../../loader/src/Tree';
+
 type refItem = Element | ComponentPublicInstance | null;
 
 const emit = defineEmits(['loaded'])
@@ -54,8 +57,15 @@ const props = defineProps({
   apiParam: {
     type: Object,
     default: () => { },
+  },
+  // 新增：是否默认展开两级
+  expandTwoLevels: {
+    type: Boolean,
+    default: true
   }
 })
+
+const lazy = ref(true)
 const refTree = ref()
 const rootNode = ref();
 const rootResolve = ref();
@@ -69,15 +79,30 @@ const defaultProps = ref({
 })
 const searchStatus = ref([])
 const screenPara = ref(props.apiParam);
-const menuVisible = ref(false)//右键菜单显示控制
-const currentData = ref({ code: "" })// 当前节点所对应的数据
-const currentNode = ref(null)//当前节点对应的 Node
-const loading = ref(false)//数据理否查询完成
+const menuVisible = ref(false)
+const currentData = ref({ code: "" })
+const currentNode = ref(null)
+const loading = ref(false)
 
 const model = ref(null)
 const nodeRef = ref()
 const retryCount = ref(0);
 const treeNodeRefMap = ref({});
+const allowedRoutes = ref([]);
+
+// 默认展开的节点key数组
+const defaultExpandedKeys = ref([])
+// 是否已设置默认展开
+const hasSetDefaultExpand = ref(false)
+// 是否是搜索状态
+const isSearching = ref(false)
+
+// 全量数据缓存
+const fullTreeData = ref([])
+
+// 新增：缓存所有节点的Map，用于快速查找
+const nodeCodeMap = ref(new Map())
+
 /** 动态设置Input Ref */
 const handleSetInputMap = (el: refItem, item) => {
   if (el) {
@@ -93,11 +118,100 @@ onBeforeUnmount(() => {
   }
 })
 
-//搜索（查询条件调用）
+// 递归获取前两级节点的key
+function getFirstTwoLevelKeys(nodes, level = 0, result = []) {
+  if (!nodes || nodes.length === 0 || level >= 1) {
+    return result;
+  }
+
+  nodes.forEach(node => {
+    if (node.code) {
+      result.push(node.code);
+    }
+
+    if (level < 1 && node.children && node.children.length > 0) {
+      getFirstTwoLevelKeys(node.children, level + 1, result);
+    }
+  });
+
+  return result;
+}
+
+// 递归获取所有节点的key（用于搜索时全展开）
+function getAllNodeKeys(nodes, result = []) {
+  if (!nodes || nodes.length === 0) {
+    return result;
+  }
+
+  nodes.forEach(node => {
+    if (node.code) {
+      result.push(node.code);
+    }
+
+    if (node.children && node.children.length > 0) {
+      getAllNodeKeys(node.children, result);
+    }
+  });
+
+  return result;
+}
+
+// 设置默认展开节点
+function setDefaultExpandedNodes() {
+  if (!props.expandTwoLevels || !fullTreeData.value.length) {
+    return;
+  }
+
+  if (isSearching.value) {
+    const allKeys = getAllNodeKeys(fullTreeData.value);
+    defaultExpandedKeys.value = allKeys;
+  } else {
+    defaultExpandedKeys.value = getFirstTwoLevelKeys(fullTreeData.value);
+  }
+
+  hasSetDefaultExpand.value = true;
+}
+
+// 新增：构建节点Map，便于快速查找
+function buildNodeCodeMap(nodes) {
+  const map = new Map();
+
+  function traverse(nodeList) {
+    nodeList.forEach(node => {
+      if (node.code) {
+        map.set(node.code, node);
+      }
+
+      if (node.children && node.children.length > 0) {
+        traverse(node.children);
+      }
+    });
+  }
+
+  traverse(nodes);
+  return map;
+}
+
+// 新增：复制节点（深拷贝）
+function cloneNode(node) {
+  const cloned = { ...node };
+  cloned.children = [];
+  return cloned;
+}
+
+// 搜索（查询条件调用）
 function search(m) {
+  const hasValidSearchConditions = checkHasValidSearchConditions(m);
+
+  isSearching.value = hasValidSearchConditions;
   screenPara.value = m;
+
+  if (!lazy.value) {
+    filterFullTreeData(screenPara.value);
+    return;
+  }
+
   if (searchStatus.value.length == 0) {
-    // 重置计数器
     retryCount.value = 0
     if (qrtimer.value) clearTimeout(qrtimer.value);
     searchStatus.value.push('a');
@@ -116,47 +230,465 @@ function search(m) {
     }, 200);
   }
 }
-//加载节点（点击节点加号时调用）
+
+// 检查是否有有效的搜索条件
+function checkHasValidSearchConditions(filter) {
+  if (!filter) return false;
+
+  let searchConditions = [];
+
+  if (filter?.searchData?.fields) {
+    searchConditions = filter.searchData.fields;
+  } else if (filter?.fields) {
+    searchConditions = filter.fields;
+  }
+
+  const validConditions = filterValidConditions(searchConditions);
+  return validConditions && validConditions.length > 0;
+}
+
+
+
+// 过滤掉 operation 为 1 的条件
+function filterValidConditions(conditions) {
+  if (!conditions || !Array.isArray(conditions)) return [];
+
+  return conditions.filter(condition => {
+    return condition.operation !== 1;
+  });
+}
+
+// 判断节点是否匹配所有搜索条件
+function nodeMatchesAllConditions(node, conditions) {
+  const validConditions = filterValidConditions(conditions);
+
+  if (!validConditions || validConditions.length === 0) return true;
+
+  return validConditions.every(condition => {
+    const { fieldName1, operation, searchValue1, searchValue2, searchDataType } = condition;
+    let nodeValue = node[fieldName1];
+
+    if (nodeValue === undefined) {
+      const mappedField = Object.keys(node).find(key =>
+        key.toLowerCase() === fieldName1.toLowerCase()
+      );
+      if (mappedField) {
+        nodeValue = node[mappedField];
+      } else {
+        return false;
+      }
+    }
+
+    const strNodeValue = String(nodeValue || '').toLowerCase();
+    const strSearchValue = String(searchValue1 || '').toLowerCase();
+
+    switch (operation) {
+      case 2:
+        return strNodeValue === strSearchValue;
+      case 3:
+        return strNodeValue !== strSearchValue;
+      case 4:
+        return Number(nodeValue) > Number(searchValue1);
+      case 5:
+        return Number(nodeValue) >= Number(searchValue1);
+      case 6:
+        return Number(nodeValue) < Number(searchValue1);
+      case 7:
+        return Number(nodeValue) <= Number(searchValue1);
+      case 8:
+        return strNodeValue.includes(strSearchValue);
+      case 9:
+        return strNodeValue.startsWith(strSearchValue);
+      case 10:
+        return strNodeValue.endsWith(strSearchValue);
+      case 11:
+        return !strNodeValue.includes(strSearchValue);
+      case 12:
+        try {
+          const regex = new RegExp(searchValue1, 'i');
+          return regex.test(nodeValue);
+        } catch (e) {
+          console.warn('正则表达式错误:', e);
+          return false;
+        }
+      case 13:
+        if (!searchValue1) return false;
+        try {
+          const values = searchValue1.split(',').map(v => v.trim().toLowerCase());
+          return values.includes(strNodeValue);
+        } catch (e) {
+          console.warn('解析IN条件错误:', e);
+          return false;
+        }
+      case 14:
+        if (!searchValue1) return true;
+        try {
+          const values = searchValue1.split(',').map(v => v.trim().toLowerCase());
+          return !values.includes(strNodeValue);
+        } catch (e) {
+          console.warn('解析NotIN条件错误:', e);
+          return false;
+        }
+      default:
+        return false;
+    }
+  });
+}
+
+// 修改：构建完整的过滤树，保持原始层级结构
+function buildFilteredTreeWithOriginalHierarchy(matchedNodes) {
+  if (!matchedNodes || matchedNodes.length === 0) {
+    return [];
+  }
+
+  const resultMap = new Map();
+  const rootNodes = [];
+
+  // 第一步：创建所有匹配节点的副本
+  matchedNodes.forEach(node => {
+    if (!resultMap.has(node.code)) {
+      const clonedNode = cloneNode(node);
+      resultMap.set(node.code, clonedNode);
+    }
+  });
+
+  // 第二步：为每个匹配节点建立完整的父子关系链
+  matchedNodes.forEach(matchedNode => {
+    // 从全量数据中查找该节点的完整路径
+    const fullNode = nodeCodeMap.value.get(matchedNode.code);
+    if (!fullNode) return;
+
+    // 递归向上查找父节点链
+    function findParentChain(currentNode, chain = []) {
+      chain.unshift(currentNode.code);
+
+      // 在全量数据中查找父节点
+      const parentCode = findParentCodeInFullTree(currentNode.code);
+      if (parentCode) {
+        const parentNode = nodeCodeMap.value.get(parentCode);
+        if (parentNode) {
+          findParentChain(parentNode, chain);
+        }
+      }
+
+      return chain;
+    }
+
+    const parentChain = findParentChain(fullNode);
+
+    // 构建完整的树结构
+    for (let i = 0; i < parentChain.length; i++) {
+      const currentCode = parentChain[i];
+
+      // 如果节点已经存在，跳过
+      if (resultMap.has(currentCode)) {
+        continue;
+      }
+
+      // 从全量数据中获取节点
+      const originalNode = nodeCodeMap.value.get(currentCode);
+      if (!originalNode) continue;
+
+      // 创建节点副本
+      const clonedNode = cloneNode(originalNode);
+      resultMap.set(currentCode, clonedNode);
+
+      // 如果是根节点，添加到根节点数组
+      if (i === 0) {
+        // 检查是否已经存在于根节点中
+        const existingRoot = rootNodes.find(n => n.code === currentCode);
+        if (!existingRoot) {
+          rootNodes.push(clonedNode);
+        }
+      }
+
+      // 连接到父节点
+      if (i > 0) {
+        const parentCode = parentChain[i - 1];
+        const parentNode = resultMap.get(parentCode);
+
+        if (parentNode) {
+          // 检查是否已经包含该子节点
+          const existingChild = parentNode.children.find(child => child.code === currentCode);
+          if (!existingChild) {
+            parentNode.children.push(clonedNode);
+          }
+        }
+      }
+    }
+
+    // 最后，确保当前匹配节点连接到其父节点
+    const parentCode = findParentCodeInFullTree(matchedNode.code);
+    if (parentCode && resultMap.has(parentCode)) {
+      const parentNode = resultMap.get(parentCode);
+      const currentNode = resultMap.get(matchedNode.code);
+
+      if (parentNode && currentNode) {
+        // 检查是否已经包含该子节点
+        const existingChild = parentNode.children.find(child => child.code === matchedNode.code);
+        if (!existingChild) {
+          parentNode.children.push(currentNode);
+        }
+      }
+    }
+  });
+
+  // 第三步：清理根节点，确保它们没有重复的父节点
+  const finalRootNodes = [];
+  const usedNodes = new Set();
+
+  function isNodeUsedInTree(node) {
+    for (const root of rootNodes) {
+      if (isNodeInChildren(root, node.code)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  rootNodes.forEach(rootNode => {
+    // 如果这个节点已经是其他节点的子节点，则不作为根节点
+    if (!isNodeUsedInTree(rootNode)) {
+      finalRootNodes.push(rootNode);
+    }
+  });
+
+  return finalRootNodes;
+}
+
+// 新增：在全量树中查找父节点code
+function findParentCodeInFullTree(nodeCode) {
+  function findParent(nodes, targetCode, parentCode = null) {
+    for (const node of nodes) {
+      if (node.code === targetCode) {
+        return parentCode;
+      }
+
+      if (node.children && node.children.length > 0) {
+        const found = findParent(node.children, targetCode, node.code);
+        if (found !== null) {
+          return found;
+        }
+      }
+    }
+    return null;
+  }
+
+  return findParent(fullTreeData.value, nodeCode);
+}
+
+// 新增：检查节点是否在子树中
+function isNodeInChildren(parentNode, targetCode) {
+  if (parentNode.code === targetCode) {
+    return false; // 不检查自身
+  }
+
+  if (!parentNode.children || parentNode.children.length === 0) {
+    return false;
+  }
+
+  for (const child of parentNode.children) {
+    if (child.code === targetCode) {
+      return true;
+    }
+
+    if (isNodeInChildren(child, targetCode)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+// 修改：过滤全量树数据，保持原始层级
+function filterFullTreeData(filter) {
+  if (!fullTreeData.value.length) {
+    return;
+  }
+
+  loading.value = true;
+  try {
+    let searchConditions = [];
+
+    if (filter?.searchData?.fields) {
+      searchConditions = filter.searchData.fields;
+    } else if (filter?.fields) {
+      searchConditions = filter.fields;
+    }
+
+    const validConditions = filterValidConditions(searchConditions);
+
+    if (!validConditions || validConditions.length === 0) {
+      refTree.value.store.setData(fullTreeData.value);
+      loading.value = false;
+      isSearching.value = false;
+      hasSetDefaultExpand.value = false;
+      defaultExpandedKeys.value = [];
+
+      // 先收起所有节点
+      if (refTree.value && refTree.value.store) {
+        Object.values(refTree.value.store.nodesMap).forEach((node: any) => {
+          if (node) {
+            node.expanded = false;
+          }
+        });
+      }
+
+      setDefaultExpandedNodes();
+      return;
+    }
+
+    // 递归查找所有匹配的节点
+    const findMatchedNodes = (nodes, result = []) => {
+      nodes.forEach(node => {
+        const nodeMatches = nodeMatchesAllConditions(node, validConditions);
+
+        if (nodeMatches) {
+          result.push(node);
+        }
+
+        if (node.children && node.children.length > 0) {
+          findMatchedNodes(node.children, result);
+        }
+      });
+      return result;
+    };
+
+    const matchedNodes = findMatchedNodes(fullTreeData.value);
+
+    // 构建保持原始层级的过滤树
+    let filteredData = [];
+    if (matchedNodes.length > 0) {
+      filteredData = buildFilteredTreeWithOriginalHierarchy(matchedNodes);
+    }
+
+    // 设置过滤后的数据
+    refTree.value.store.setData(filteredData);
+
+    // 搜索状态时展开所有节点
+    if (filteredData.length > 0 && isSearching.value) {
+      const allKeys = getAllNodeKeys(filteredData);
+      defaultExpandedKeys.value = allKeys;
+
+      nextTick(() => {
+        if (refTree.value && refTree.value.store) {
+          Object.values(refTree.value.store.nodesMap).forEach((node: any) => {
+            if (node) {
+              node.expanded = true;
+            }
+          });
+        }
+      });
+
+      // 默认选中第一个可选节点
+      const findFirstSelectableNode = (nodes) => {
+        for (const node of nodes) {
+          if (!node.children || node.children.length === 0) {
+            return node;
+          }
+          const childResult = findFirstSelectableNode(node.children);
+          if (childResult) return childResult;
+        }
+        return nodes[0];
+      };
+
+      const firstNode = findFirstSelectableNode(filteredData);
+      if (firstNode && firstNode.code) {
+        nextTick(() => {
+          refTree.value.setCurrentKey(firstNode.code);
+          handleNodeClick(firstNode, true);
+        });
+      }
+    }
+
+  } catch (error) {
+    console.error('过滤树数据失败:', error);
+  } finally {
+    loading.value = false;
+  }
+}
+
+// 修改：加载节点，保存节点Map
 function loadNode(node, resolve) {
+
+  if (!lazy.value) {
+    const nodeData = node.data;
+    resolve(nodeData.children)
+    return;
+  }
+
   if (node.level === 0) {
     loading.value = true;
     rootNode.value = node
     rootResolve.value = resolve;
+
     return SearchTree(screenPara.value || undefined).then(data => {
       loading.value = false;
-      resolve(data.rows);
-      load(data, true)
+
+
+      const { tree, hasAnyLeaf } = buildDeptTreeByField(data.rows, data.source.content.columns || [], {
+        pathKey: 'deptPath',
+        separator: '.'
+      });
+
+      // 缓存全量数据并构建节点Map
+      if (hasAnyLeaf) {
+        fullTreeData.value = tree;
+        nodeCodeMap.value = buildNodeCodeMap(tree);
+        resolve(tree);
+        if (props.expandTwoLevels) {
+          nextTick(() => {
+            hasSetDefaultExpand.value = false;
+            setDefaultExpandedNodes();
+          });
+        }
+      }
+      else {
+        resolve(data.rows);
+      }
+      lazy.value = !hasAnyLeaf;
+
+      load(data, true);
+    }).catch(error => {
+      loading.value = false;
+      console.error('加载树数据失败:', error);
     });
   }
-  if (node.level >= 1) {
+
+  if (node.level >= 1 && lazy.value) {
     let fields = model.value.searchData("code", node.data.code, 9, 3);
     let filter = {
       "searchData": {
-        // 先保留searchData的其他属性
         ...(screenPara.value?.searchData || {}),
-        // 再合并fields数组（将两个数组合并，而不是覆盖）
         fields: [
           ...fields.fields,
           ...(screenPara.value?.searchData?.fields || [])
         ]
       }
-    };
+    }; 
+
     return SearchTree(filter).then(data => {
       loading.value = false;
       resolve(data.rows);
-      load(data, false)
+      load(data, false);
+    }).catch(error => {
+      loading.value = false;
+      console.error('加载子节点失败:', error);
     });
   }
 }
-//加载数据
-async function load(data, firstLoad) {
+
+// 加载数据
+async function load(data, flagRootNode) {
   model.value = data;
   if (searchStatus.value.length > 0) {
     searchStatus.value = searchStatus.value.slice(1)
   }
+
   loading.value = false;
   menuVisible.value = false;
-  if (firstLoad) {
+
+  if (flagRootNode) {
     if (model.value.rows && model.value.rows[0]) {
       handleNodeClick(model.value.rows[0], true);
     }
@@ -167,17 +699,77 @@ async function load(data, firstLoad) {
     });
   }
 }
-//查询数据
-function SearchTree(m) {
 
+// 查询数据
+function SearchTree(m) {
   return new Promise((resolve, reject) => {
     if (typeof props.api !== 'undefined') {
-
-      resolve(Tree.loadSearchTreeApi(props.api, m));
+      Tree.loadSearchTreeApi(props.api, m)
+        .then(resolve)
+        .catch(reject);
+    } else {
+      reject(new Error('API未定义'));
     }
   });
 }
-//节点击点事件
+
+// 重置树到全量数据
+function resetTree() {
+  isSearching.value = false;
+  if (fullTreeData.value.length > 0) {
+    refTree.value.store.setData(fullTreeData.value);
+    hasSetDefaultExpand.value = false;
+    defaultExpandedKeys.value = [];
+
+    if (fullTreeData.value[0] && fullTreeData.value[0].code) {
+      nextTick(() => {
+        if (refTree.value && refTree.value.store) {
+          Object.values(refTree.value.store.nodesMap).forEach((node: any) => {
+            if (node) {
+              node.expanded = false;
+            }
+          });
+        }
+
+        refTree.value.setCurrentKey(fullTreeData.value[0].code);
+        handleNodeClick(fullTreeData.value[0], true);
+        setDefaultExpandedNodes();
+      });
+    }
+  }
+}
+
+// 清除搜索条件
+function clearSearch() {
+  screenPara.value = {};
+  isSearching.value = false;
+
+  defaultExpandedKeys.value = [];
+  hasSetDefaultExpand.value = false;
+
+  if (fullTreeData.value.length > 0) {
+    refTree.value.store.setData(fullTreeData.value);
+
+    nextTick(() => {
+      if (refTree.value && refTree.value.store) {
+        Object.values(refTree.value.store.nodesMap).forEach((node: any) => {
+          if (node) {
+            node.expanded = false;
+          }
+        });
+      }
+
+      setDefaultExpandedNodes();
+
+      if (fullTreeData.value[0] && fullTreeData.value[0].code) {
+        refTree.value.setCurrentKey(fullTreeData.value[0].code);
+        handleNodeClick(fullTreeData.value[0], true);
+      }
+    });
+  }
+}
+
+//节点点击事件
 function handleNodeClick(data, formType) {
   closeMenu();
   if (data && formType) {
@@ -194,33 +786,41 @@ function handleNodeClick(data, formType) {
     })
     model.value.requestAction(rowRouter.action, SearchData, function (rowdata) {
       var newdata = common.deepClone(data);
+      delete newdata.children;
+
       if (rowdata) {
-        newdata.rowRouter = rowdata
+        newdata.rowRouter = rowdata;
       }
       newdata.title = model.value.source?.content?.title || '';
       emit('loaded', newdata);
     });
   }
 }
+
 //右键菜单
-function rightClick(event, object, Node) { // event、object该节点所对应的对象、节点对应的 Node、节点组件本身
+function rightClick(event, object, Node) {
   nodeRef.value = treeNodeRefMap.value[`node_Ref_${object.code}`]
 
   currentData.value = object
   currentNode.value = Node
   let actionIndex = 0;
-  if (model.value.actionRouter) {
-    model.value.actionRouter.forEach(v => {
-      if (currentData.value[v.rightField] == '1') {
-        menuVisible.value = true //显示增删改的div
-        actionIndex += 1;
-      }
-    })
-  }
+
+  allowedRoutes.value = (model.value.actionRouter || []).filter(v => {
+    const val = currentData.value[v.rightField]
+    const hit = val == '1' || val === undefined || val === null;
+    return hit;
+  })
+
+  allowedRoutes.value?.forEach(() => {
+    menuVisible.value = true
+    actionIndex += 1
+  })
+
   if (menuVisible.value) {
-    document.addEventListener('click', closeMenu) // 监听事件鼠标点击事件，若点击则隐藏菜单 
+    document.addEventListener('click', closeMenu)
   }
 }
+
 //关闭菜单
 function closeMenu() {
   menuVisible.value = false;
@@ -228,6 +828,7 @@ function closeMenu() {
   currentData.value = { ...currentData.value, code: "" }
   document.removeEventListener('click', closeMenu)
 }
+
 // 菜单路由
 function routerClickHandler(field) {
   var submitData = {};
@@ -238,48 +839,48 @@ function routerClickHandler(field) {
 
   RouterClickHandler(field, submitData, null, model.value, 'tree', function (newData) {
     switch (field.actionType) {
-      case Enum.ActionType.Delete://删除
-      case Enum.ActionType.CloseTabThenDelete://删除
-        removeNode(newData);//删除树节点
+      case Enum.ActionType.Delete:
+      case Enum.ActionType.CloseTabThenDelete:
+        removeNode(newData);
         break;
-      case Enum.ActionType.New://新增
-      case Enum.ActionType.CloseTabThenNew://新增 
-        addNode(newData)//新增树节点
+      case Enum.ActionType.New:
+      case Enum.ActionType.CloseTabThenNew:
+        addNode(newData)
         break;
-      case Enum.ActionType.Update://修改
-      case Enum.ActionType.CloseTabThenUpdate://修改
-        updateNode(newData)//修改树节点 
+      case Enum.ActionType.Update:
+      case Enum.ActionType.CloseTabThenUpdate:
+        updateNode(newData)
         break;
       default:
         break;
     }
-
   })
 }
+
 //删除树节点
 function removeNode(newData) {
   getNextClickNode()
   refTree.value.remove(currentNode.value);
 }
+
 //新增树节点
 function addNode(newData) {
   refTree.value.append(newData, currentNode.value)
   handleNodeClick(newData, true)
 }
+
 //修改树节点
 function updateNode(newData) {
-
   for (let key in newData) {
-
     if (typeof newData[key] === 'object') {
       currentData.value[key] = { ...currentData.value[key], ...newData[key] }
     } else {
       currentData.value[key] = newData[key];
     }
-
   }
   handleNodeClick(newData, true)
 }
+
 function getNextClickNode() {
   const node = refTree.value.getNode(currentData.value.code);
   let data = {};
@@ -292,9 +893,106 @@ function getNextClickNode() {
   }
   handleNodeClick(data, true)
 }
-// //把属性和方法暴露
+
+/** 过滤节点（全量数据模式下使用） */
+function filterNode(value, data) {
+  if (!value) return true
+  return data.name.toLowerCase().includes(value.toLowerCase())
+}
+
+function buildDeptTreeByField(flatList, fieldDefine, opt = {}) {
+  const {
+    pathKey = 'path',
+    separator = '.',
+    sortKey = 'path'
+  } = opt;
+
+  const keepFields = fieldDefine
+    .filter(f => f.visible && f.isDataField)
+    .sort((a, b) => a.trOrder - b.trOrder)
+    .map(f => f.fieldName);
+
+  const createNode = (tplItem, path) => {
+    const node = { children: [] };
+
+    for (const key in tplItem) {
+      if (key !== 'children') {
+        node[key] = tplItem[key];
+      }
+    }
+
+    node[pathKey] = path;
+    return node;
+  };
+
+  const root = [];
+  const nodeMap = new Map();
+
+  for (const item of flatList) {
+
+    if (!item[pathKey]) {
+      break;
+    }
+    const path = item[pathKey];
+    const levels = path.split(separator);
+
+    let curPath = '';
+    let parentPath = '';
+
+    levels.forEach((lvl, idx) => {
+      curPath = idx === 0 ? lvl : `${parentPath}${separator}${lvl}`;
+      let curNode = nodeMap.get(curPath);
+
+      if (!curNode) {
+        curNode = createNode(item, curPath);
+        nodeMap.set(curPath, curNode);
+
+        if (idx === 0) {
+          root.push(curNode);
+        } else {
+          const pNode = nodeMap.get(parentPath);
+          if (pNode) {
+            pNode.children.push(curNode);
+          }
+        }
+      }
+      parentPath = curPath;
+    });
+
+    const lastNode = nodeMap.get(path);
+    for (const key in item) {
+      if (key !== 'children') {
+        lastNode[key] = item[key];
+      }
+    }
+  }
+
+  for (const node of nodeMap.values()) {
+    if (node.children && node.children.length > 0) {
+      node.children.sort((a, b) => {
+        const aVal = a[sortKey] || '';
+        const bVal = b[sortKey] || '';
+        return String(aVal).localeCompare(String(bVal));
+      });
+    }
+    node.isLeaf = node.children.length === 0;
+  }
+
+  root.sort((a, b) => {
+    const aVal = a[sortKey] || '';
+    const bVal = b[sortKey] || '';
+    return String(aVal).localeCompare(String(bVal));
+  });
+
+  const hasAnyLeaf = [...nodeMap.values()].some(n => n.isLeaf == false);
+  return { tree: root, hasAnyLeaf };
+}
+
+// 暴露方法
 defineExpose({
-  search
+  search,
+  resetTree,
+  clearSearch
 })
 </script>
 
@@ -310,7 +1008,6 @@ defineExpose({
 
 .ct-tree::-webkit-scrollbar-thumb {
   background-color: #bebebe;
-  /* 设置滚动条滑块颜色 */
   height: 5px;
   border-radius: 4px;
   display: block;
@@ -319,7 +1016,6 @@ defineExpose({
 .ct-tree::-webkit-scrollbar {
   width: 6px;
   height: 6px;
-  /* 设置滚动条高度 */
   background-color: #f1f1f1;
   display: block;
 }
@@ -347,121 +1043,14 @@ defineExpose({
   padding-right: 2px !important;
 }
 
-/* 竖线 */
-.el-tree-node::before {
-  content: "";
-  height: 100%;
-  width: 1px;
-  position: absolute;
-  left: 27px;
-  top: -1px;
-  border-width: 1px;
-  border-left: 1px dashed #52627C;
-}
-
-.tree-line .el-tree-node:before:last-child {
-  top: -35px;
-}
-
-.el-tree-node__children .el-tree-node::before {
-  content: "";
-  height: 100%;
-  width: 1px;
-  position: absolute;
-  left: 27px;
-  top: -2px;
-  border-width: 1px;
-  border-left: 1px dashed #52627C;
-}
-
-/* 当前最后一个接点的竖线高度 */
-.el-tree-node:last-child::before {
-  height: 15px;
-  /*可以自己调整 */
-}
-
-/* 横线 */
-.el-tree-node::after {
-  content: "";
-  width: 12px;
-  height: 20px;
-  position: absolute;
-  left: 27px;
-  top: 12px;
-  right: 2px;
-  border-width: 1px;
-  border-top: 1px dashed #52627C;
-}
-
-.el-tree:first-child .el-tree-node:before {
-  /* height: 46px;可以自己调整 */
-}
-
-.el-tree-node__expand-icon {
-  font-size: 16px;
-}
-
-/* 去掉顶层虚线 */
-.tree>.el-tree-node:first-child::after {
-  border-top: none;
+.node_content {
+  display: flex;
+  align-items: center;
 }
 
-.el-tree>.el-tree-node:first-child:before {
-  /* border-left: none; */
-}
-
-.tree>.is-leaf {
-  color: transparent;
-}
-
-.el-tree .el-tree-node__expand-icon.expanded {
-  -webkit-transform: rotate(0deg);
-  transform: rotate(0deg);
-}
-
-.el-tree .el-tree-node__expand-icon.expanded {
-  -webkit-transform: rotate(0deg);
-  transform: rotate(0deg);
-}
-
-
-.el-tree .el-tree-node__expand-icon {
-  background: url("@/assets/images/node-collapse.png") no-repeat;
-  content: '';
-  display: block;
-  width: 12px;
-  height: 12px;
-  font-size: 12px;
-  background-size: 10px;
-
-  color: transparent;
-  background-position: left 6px top 6px;
-}
-
-/*
-  //有子节点 且已展开*/
-.el-tree .el-tree-node__expand-icon.expanded {
-  background: url("@/assets/images/node-expand.png") no-repeat;
-  content: '';
-  display: block;
-  width: 12px;
-  height: 12px;
-  font-size: 12px;
-  background-size: 10px;
-
-  color: transparent;
-  background-position: left 6px top 6px;
-}
-
-/*  //没有子节点*/
-.el-tree .el-tree-node__expand-icon.is-leaf::before {
-  background: transparent no-repeat 0 3px;
-  content: '';
-  display: block;
-  width: 12px;
-  height: 12px;
-  font-size: 12px;
-  background-size: 10px;
+.node-icon {
+  margin-right: 5px;
+  color: var(--el-color-warning);
 }
 
 .box-menu {
@@ -481,5 +1070,6 @@ defineExpose({
 
 .box-menu .opertion:hover {
   color: var(--btnHoverRed);
+  background-color: var(--el-fill-color-light);
 }
-</style>
+</style>