选择用户优化

src/components/formTable/index.vue

@@ -636,7 +636,7 @@ function checkRangedUserTreesAndGet(){
 
 onMounted(() => {
 	getAsfs()
-	checkRangedUserTreesAndGet()
+	
 	
 	getInitModel()
 	nextTick(() => {
@@ -1915,6 +1915,7 @@ watch(
 }) */
 const treeUrl = '/javasys/lowCode/transfer/getOrgAndManTree'
 const orgAndManTree = ref()
+
 function getOrgAndManTree() {
     return request({
         url: treeUrl,
@@ -1925,15 +1926,196 @@ function getTree1() {
     getOrgAndManTree().then(({ data }) => {
         orgAndManTree.value = data
 
-    })
+    }).finally(()=>{
+		console.log(rangedUserTrees)
+
+		// 使用示例
+		const configArray = rangedUserTrees;
+		const groupedNames = groupExpandUserConfigs(configArray);
+		console.log(groupedNames);
+		groupedNames.forEach((element:any) => {
+			let keys = element.keys
+			let arr = []
+			arr.push(modifyTreeData(orgAndManTree.value,keys))
+			element.tree = arr
+
+			rangedUserTrees.forEach((item:any) => {
+				let i = 0
+				element.groupArray.forEach((el:any) => {
+					if(item.name==el){
+						i++
+					}
+				});
+				if(i>0){
+					item.tree = element.tree
+				}
+			});
+		});
+		rangedUserTrees1.value = rangedUserTrees
+	})
+	
+	
 }
 
 
 
-const rangedUserTrees: any[] = [];
+
+function modifyTreeData(treeData, idList) {
+    console.log("modifyTreeDataMinimal 执行了");
+    
+    const idArray = Array.isArray(idList) ? idList : [idList];
+    if (idArray.length === 0 || !treeData) {
+        return Array.isArray(treeData) ? [] : null;
+    }
+    
+    const roots = Array.isArray(treeData) ? treeData : [treeData];
+    
+    // 创建节点映射和父节点映射
+    const nodeMap = new Map();
+    const parentMap = new Map();
+    
+    // 使用迭代而非递归构建映射，避免栈溢出
+    const stack = [...roots];
+    
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (!node?.id) continue;
+        
+        nodeMap.set(node.id, node);
+        
+        if (node.children) {
+            for (const child of node.children) {
+                if (child?.id) {
+                    parentMap.set(child.id, node.id);
+                    stack.push(child);
+                }
+            }
+        }
+    }
+    
+    // 找到需要保留的节点（目标节点及其祖先）
+    const keepIds = new Set();
+    for (const id of idArray) {
+        let currentId = id;
+        while (currentId && nodeMap.has(currentId)) {
+            keepIds.add(currentId);
+            currentId = parentMap.get(currentId);
+        }
+    }
+    
+    // 构建结果树 - 修复重复问题
+    const result = [];
+    const processedIds = new Set(); // 跟踪已处理的节点ID，防止重复
+    
+    // 只处理根节点中需要保留的节点
+    for (const root of roots) {
+        if (!root?.id || !keepIds.has(root.id) || processedIds.has(root.id)) {
+            continue;
+        }
+        
+        processedIds.add(root.id);
+        result.push(buildNodeTree(root, keepIds, idArray, processedIds));
+    }
+    
+    // 清理临时数据
+    nodeMap.clear();
+    parentMap.clear();
+    keepIds.clear();
+    processedIds.clear();
+    
+    return Array.isArray(treeData) ? result : result[0] || null;
+}
+
+// 辅助函数：递归构建节点树
+function buildNodeTree(node, keepIds, idArray, processedIds) {
+    const newNode = { 
+        id: node.id,
+        label: node.label,
+        value: node.value
+    };
+    
+    // 修改目标节点的标签
+    if (idArray.includes(node.id)) {
+        newNode.label = `${node.label}(${node.value || ''})`;
+        newNode.number = newNode.label;
+    }
+    
+    // 处理子节点
+    if (node.children && node.children.length > 0) {
+        const children = [];
+        for (const child of node.children) {
+            if (child?.id && keepIds.has(child.id) && !processedIds.has(child.id)) {
+                processedIds.add(child.id);
+                children.push(buildNodeTree(child, keepIds, idArray, processedIds));
+            }
+        }
+        if (children.length > 0) {
+            newNode.children = children;
+        }
+    }
+    
+    return newNode;
+}
+
+
+
+
+function groupExpandUserConfigs(configs) {
+    // 用于存储分组结果的Map
+    // key是排序后的范围数组字符串，value是包含names和原始keys的对象
+    const groupMap = new Map();
+    
+    configs.forEach(config => {
+        // 根据queryBy确定使用哪个范围数组
+        let range, rangeType;
+        if (config.control.queryBy === 'org') {
+            range = config.control.orgRange;
+            rangeType = 'orgRange';
+        } else {
+            range = config.control.roleRange;
+            rangeType = 'roleRange';
+        }
+        
+        // 对范围数组进行排序并转换为字符串作为分组key
+        const sortedRange = [...range].sort().join(',');
+        
+        // 如果该分组key不存在，创建新的分组
+        if (!groupMap.has(sortedRange)) {
+            groupMap.set(sortedRange, {
+                names: [],
+                keys: range, // 存储原始keys，不排序
+                rangeType: rangeType
+            });
+        }
+        
+        // 将当前配置的name添加到对应分组
+        groupMap.get(sortedRange).names.push(config.name);
+    });
+    
+    // 将Map转换为要求的输出格式
+    const result = [];
+    for (const groupInfo of groupMap.values()) {
+        result.push({
+            groupArray: groupInfo.names,
+            keys: groupInfo.keys,
+            rangeType: groupInfo.rangeType // 可选：添加范围类型信息
+        });
+    }
+    
+    return result;
+}
+
+
+
+
+
+const rangedUserTrees1= ref([]);
+const rangedUserTrees :any= [];
 
 function getAsfs() {
-	setTimeout(() => {
+	/* setTimeout(() => { */
+
+	if(props.formData.list&&props.formData.list.length>0){
 		let dataList = ref({});
 		dataList.value = props.formData.list;
 
@@ -2011,8 +2193,15 @@ function getAsfs() {
 			}
 			}
 		}
+		checkRangedUserTreesAndGet()
 		}
-	}, 500);
+	}else{
+		setTimeout(()=>{
+			getAsfs()
+		},100)
+	}
+		
+	/* }, 500); */
 }
 
 /* function getAsfs() {
@@ -2114,7 +2303,7 @@ defineExpose({
 				'design-form': type === 5,
 				'detail-form': type === 3
 			}">
-			<FormItemGroup :tableinfo="formData.form" :data="formData.list" :alldata="formData" :org-and-man-tree="orgAndManTree" />
+			<FormItemGroup :tableinfo="formData.form" :data="formData.list" :alldata="formData" :org-and-man-tree="rangedUserTrees1" />
 			<slot></slot>
 		</el-form>
 	</div>

src/components/lowCode/assistant/rangedUserTree.vue

@@ -1,10 +1,8 @@
 
 <script lang='ts' setup>
-import { criteriaForPeopleList } from '@/api/hr/org/type'
+
-import SvgIcon from '@/components/svgIcon/index.vue'
+import { computed,ref,watch,onBeforeMount} from 'vue'
-import { useAttrs,computed, onMounted, nextTick,ref,watch,onBeforeMount} from 'vue'
+
-import request from '@/utils/axios/index'
-const attrs = useAttrs()
 const props = withDefaults(
     defineProps<{
 		modelValue?: string
@@ -12,20 +10,11 @@ const props = withDefaults(
 		types?:number
         control?:any
         orgAndManTree?: any;
+        data?: any;
     }>(),
     {}
 )
-interface User {
+
-  id: number
-  name: string
-  number: string
-  key: string
-  icon: string
-  department: string
-  role: string
-  label: string
-  value: string
-}
 const emits = defineEmits<{
     (e: 'update:modelValue', value: string): void
 }>()
@@ -73,7 +62,6 @@ function parseStringToArray(str:string) {
     }
 }
 onBeforeMount(() => {
-    checkorgAndManTree()
 	setTimeout(()=>{
 		value.value = parseStringToArray(props.modelValue)
 	},500 )
@@ -81,267 +69,79 @@ onBeforeMount(() => {
 
 
 
-const keys = computed(()=>{
+const resData = computed(()=>{
-	if(attrs.queryBy == 'role'){
+    return checkorgAndManTree1()
-		return attrs.roleRange
-	}else{
-		return attrs.orgRange
-	}
 })
 
-
+function checkorgAndManTree1(){
-// 使用示例
+    let result = []
-const treeData = {
+    let i = 0
-    "id": "102",
+    props.orgAndManTree.forEach((element : any) => {
-    "label": "企管部",
+        if(element.hasOwnProperty('tree')&&hasNodesInTree(element.tree)){
-    "parentId": "309",
+            i++
-    "children": [
-        {
-            "id": "284148167597887488",
-            "label": "荣潇亭",
-            "parentId": "102",
-            "children": null,
-            "value": "303086",
-            "treeAttrs": null,
-            "disabled": null,
-            "type": null
-        },
-        {
-            "id": "272",
-            "label": "企管",
-            "parentId": "102",
-            "children": [
-                {
-                    "id": "284148287831805952",
-                    "label": "吴可楠",
-                    "parentId": "272",
-                    "children": null,
-                    "value": "303122",
-                    "treeAttrs": null,
-                    "disabled": null,
-                    "type": null
-                }
-            ],
-            "value": null,
-            "treeAttrs": null,
-            "disabled": null,
-            "type": null
         }
-    ],
+    });
-    "value": null,
+    if(i==props.orgAndManTree.length){
-    "treeAttrs": null,
+        props.orgAndManTree.forEach((item : any) => {
-    "disabled": null,
-    "type": null
-};
-
-const idList = ["284148167597887488", "284148287831805952"];
-
-const resData = ref()
 
-const checkorgAndManTree = (()=>{
+            if(props.data.name==item.name){
-    if(props.orgAndManTree&&props.orgAndManTree.children&&props.orgAndManTree.children.length>0){
+                console.log(item.tree)
-        //alert(1)
+                result =  item.tree
-        let arr = []
+            }
-        arr.push(modifyTreeData(props.orgAndManTree,keys.value))
+            
-        
+        });
-        resData.value = arr
+        return result
     }else{
         setTimeout(()=>{
-            checkorgAndManTree()
+            checkorgAndManTree1()
         },100)
     }
-})
-
-
-
-const resultExample = [{
-    "id": "102",
-    "label": "企管部",
-    "parentId": "309",
-    "children": [
-        {
-            "id": "284148167597887488",
-            "label": "荣潇亭(303086)",
-            "parentId": "102",
-            "children": null,
-            "value": "303086",
-            "treeAttrs": null,
-            "disabled": null,
-            "type": null,
-            "number": "荣潇亭(303086)"
-        },
-        {
-            "id": "272",
-            "label": "企管",
-            "parentId": "102",
-            "children": [
-                {
-                    "id": "284148287831805952",
-                    "label": "吴可楠(303122)",
-                    "parentId": "272",
-                    "children": null,
-                    "value": "303122",
-                    "treeAttrs": null,
-                    "disabled": null,
-                    "type": null,
-                    "number": "吴可楠(303122)"
-                }
-            ],
-            "value": null,
-            "treeAttrs": null,
-            "disabled": null,
-            "type": null
-        }
-    ],
-    "value": null,
-    "treeAttrs": null,
-    "disabled": null,
-    "type": null
-}]
-
 
 
+    
+}
 
 
-function modifyTreeData(treeData, idList) {
+/**
-    // 深拷贝树数据，避免修改原数据
+ * 判断树形结构是否存在节点
-    const newTreeData = JSON.parse(JSON.stringify(treeData));
+ * @param {Array} tree 树形结构数组（最外层为数组，每个节点可能包含children属性）
-    
+ * @returns {boolean} 存在节点返回true，否则返回false
-    // 确保idList是一个数组
+ */
-    const idArray = Array.isArray(idList) ? idList : [idList];
+function hasNodesInTree(tree) {
-    if (idArray.length === 0) return Array.isArray(newTreeData) ? [] : null;
+    // 边界条件：如果输入不是数组，直接返回false
-    
+    if (!Array.isArray(tree)) {
-    // 1. 收集所有节点，记录：id→节点映射、id→父节点id映射（检测多父节点）
+        return false;
-    const nodeMap = new Map(); // id → 节点
-    const parentMap = new Map(); // id → 父节点id（确保每个节点只有一个父节点）
-    const multiParentIds = new Set(); // 记录有多个父节点的id
-    
-    function collectNodes(node, parentId) {
-        if (!node || typeof node !== 'object' || !node.id) return; // 跳过无效节点
-        
-        // 记录节点映射
-        if (!nodeMap.has(node.id)) {
-            nodeMap.set(node.id, node);
-        }
-        
-        // 记录父节点（检测多父节点）
-        if (parentMap.has(node.id)) {
-            // 已存在父节点，且与当前父节点不同 → 多父节点
-            if (parentMap.get(node.id) !== parentId) {
-                multiParentIds.add(node.id);
-            }
-        } else {
-            parentMap.set(node.id, parentId); // 首次记录父节点
-        }
-        
-        // 递归处理子节点，传入当前节点id作为父节点id
-        if (node.children && Array.isArray(node.children)) {
-            node.children.forEach(child => collectNodes(child, node.id));
-        }
-    }
-    
-    // 处理根节点（可能是单个节点或数组）
-    if (Array.isArray(newTreeData)) {
-        newTreeData.forEach(root => collectNodes(root, null)); // 根节点父id为null
-    } else {
-        collectNodes(newTreeData, null);
-    }
-    
-    // 警告多父节点问题（核心重复原因）
-    if (multiParentIds.size > 0) {
-        console.warn(`以下节点存在多个父节点，可能导致重复：${Array.from(multiParentIds).join(', ')}`);
     }
-    
+
-    // 2. 收集需要保留的节点ID：目标节点+直系祖先（基于parentMap追溯，确保唯一路径）
+    // 递归检查节点及其子节点
-    const keepIds = new Set();
+    function checkNode(node) {
-    idArray.forEach(targetId => {
+        // 节点本身存在（非null/undefined）即算一个节点
-        let currentId = targetId;
+        if (node == null) {
-        // 从目标节点向上追溯，直到根节点（parentId为null）
+            return false;
-        while (currentId !== null && nodeMap.has(currentId)) {
-            keepIds.add(currentId);
-            currentId = parentMap.get(currentId); // 基于唯一父节点追溯
-        }
-    });
-    
-    // 3. 过滤树结构：仅保留keepIds中的节点，且严格校验子节点的parentId是否匹配当前父节点
-    function filterTree(node) {
-        if (!node || typeof node !== 'object' || !keepIds.has(node.id)) {
-            return null;
-        }
-        
-        // 复制节点（避免修改原引用）
-        const filteredNode = { ...node };
-        
-        // 处理子节点：仅保留符合条件的子节点（在keepIds中，且parentId等于当前节点id）
-        if (filteredNode.children && Array.isArray(filteredNode.children)) {
-            // 临时存储符合条件的子节点（去重）
-            const validChildren = new Map(); // 用id去重
-            
-            filteredNode.children.forEach(child => {
-                // 校验：子节点必须在keepIds中，且其父节点id是当前节点id
-                if (child && typeof child === 'object' && child.id && 
-                    keepIds.has(child.id) && parentMap.get(child.id) === filteredNode.id) {
-                    const filteredChild = filterTree(child);
-                    if (filteredChild) {
-                        validChildren.set(filteredChild.id, filteredChild); // 用id去重
-                    }
-                }
-            });
-            
-            // 转为数组，保持原数据格式（空数组→null）
-            filteredNode.children = Array.from(validChildren.values());
-            if (filteredNode.children.length === 0) {
-                filteredNode.children = null;
-            }
-        } else {
-            filteredNode.children = null;
         }
-        
+        // 只要当前节点存在，就返回true
-        return filteredNode;
+        return true;
     }
-    
+
-    // 处理根节点（数组或单个节点）
+    // 遍历根节点数组，只要有一个节点存在，就返回true
-    let filteredTree;
+    for (const node of tree) {
-    if (Array.isArray(newTreeData)) {
+        if (checkNode(node)) {
-        // 根节点必须在keepIds中，且父节点为null
+            // 即使当前节点没有子节点，自身也算一个节点
-        filteredTree = newTreeData
+            return true;
-            .map(root => {
-                if (root && keepIds.has(root.id) && parentMap.get(root.id) === null) {
-                    return filterTree(root);
-                }
-                return null;
-            })
-            .filter(Boolean);
-    } else {
-        filteredTree = (keepIds.has(newTreeData.id) && parentMap.get(newTreeData.id) === null) 
-            ? filterTree(newTreeData) 
-            : null;
-    }
-    
-    // 4. 对目标节点修改label和添加number属性
-    function modifyLabels(node) {
-        if (!node || typeof node !== 'object') return;
-        
-        if (idArray.includes(node.id)) {
-            const newLabel = `${node.label}(${node.value || ''})`;
-            node.label = newLabel;
-            node.number = newLabel;
         }
-        
+        // 如果当前节点有子节点，递归检查子节点（防止极端情况：当前节点为空但子节点存在）
-        if (node.children && Array.isArray(node.children)) {
+        if (Array.isArray(node?.children) && hasNodesInTree(node.children)) {
-            node.children.forEach(child => modifyLabels(child));
+            return true;
         }
     }
-    
+
-    // 执行标签修改
+    // 所有层级都没有节点
-    if (Array.isArray(filteredTree)) {
+    return false;
-        filteredTree.forEach(root => modifyLabels(root));
-    } else {
-        modifyLabels(filteredTree);
-    }
-    
-    return filteredTree;
 }
+
+
+
+
 const valPrint = (val:any) => {
 	
 		if(Array.isArray(val)){
@@ -364,20 +164,6 @@ const valPrint = (val:any) => {
 
 
 
-/* ::v-deep .el-tree-node__expand-icon {
-
-  font-size: 38px; 
- 
-  width: 34px; 
-  height: 34px;
-  line-height: 34px; 
-}
-
-
-::v-deep .el-tree-node__expand-icon::before {
-  font-size: 38px; 
-}
- */
 
 .el-tree-node__expand-icon {
     color: var(--el-tree-expand-icon-color);

src/views/formTable/taskListPage.vue

@@ -656,7 +656,7 @@ const performAction = (val) => {}
         <TimeAxis v-if="activeName=='4'" ref="cardPageRef" v-model:page-id-ary="pageIdAry" :app-key="appKey" :app-id="appId" :task-id="taskId" :task-key="taskKey" :task-title="taskTitle" :stateList-info="stateList" :state-form="stateForm" :app-flow-info="appFlowInfo" :form-table-str="formTableStr" />
         <mapPage  v-if="activeName=='6'" ref="cardPageRef" v-model:page-id-ary="pageIdAry" :app-key="appKey" :app-id="appId" :task-id="taskId" :task-key="taskKey" :task-title="taskTitle" :stateList-info="stateList" :state-form="stateForm" :app-flow-info="appFlowInfo" :form-table-str="formTableStr" />
 
-        <AppPageInfo v-model:is-show="openAppPage" :app-info="appContent" :app-page-info="lookInfo" :state-form="stateForm" :app-flow-info="appFlowInfo" :form-table-str="formTableStr" @searchData="chaxunData" />
+        <AppPageInfo v-if="openAppPage" v-model:is-show="openAppPage" :app-info="appContent" :app-page-info="lookInfo" :state-form="stateForm" :app-flow-info="appFlowInfo" :form-table-str="formTableStr" @searchData="chaxunData" />
     </div>
 </template>
 <style  lang='scss' scoped>