图层树

lixuliang

2024-04-29 415eb8a7e065301203568dd4e2d9c9dbdbe51f14

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
// 遍历节点
function ergodicNode(nodes) {
    if (nodes && nodes.length) {
        nodes.forEach((item) => {
            item.rename = false;
            item.children && ergodicNode(item.children);
        });
    }
}
 
/**
 * 图层树数据
 */
export default {
    namespaced: true,
    state: {
        // 工程树数据
        treeData: [],
    },
    mutations: {
        // 定义工程树数据
        setTreeData(state, data = []) {
            ergodicNode(data);
            state.treeData = data;
        },
        // 树指定位置增加子节点（必须标识为key）
        addTreeChildren({ treeData }, { parentNode, pid, item }) {
            if (!pid) {
                treeData.push(item)
                return;
            }
            (parentNode || treeData).forEach(ele => {
                if (ele.id === pid) {
                    if (ele.children) {
                        ele.children.push(item)
                    } else {
                        (parentNode || treeData).push(item)
                    }
 
                    return;
                } else {
                    if (ele.children) {
                        this.commit('layerTree/addTreeChildren', {
                            parentNode: ele.children,
                            pid,
                            item
                        })
                    }
                }
            })
        },
        // 勾选节点
        checkTreeNode({ treeData }, { parentNode, id, checked }) {
            (parentNode || treeData).forEach(ele => {
                if (!id || (id && ele.id === id)) {
                    // id不存，勾选所有子节点，id存在，勾选当前节点
                    ele.checked = checked;
                    if (ele.children) {
                        this.commit('layerTree/checkTreeNode', { parentNode: ele.children, checked });
                    } else if (ele._children) {
                        this.commit('layerTree/checkTreeNode', { parentNode: ele._children, checked });
                    }
                    if (id) {
                        return;
                    }
                } else {
                    // 递归
                    if (ele.children) {
                        this.commit('layerTree/checkTreeNode', {
                            parentNode: ele.children,
                            id,
                            checked
                        })
                    }
                }
            })
        },
        // 更新节点数据
        updataTreeNode({ treeData }, { parentNode, id, nodeValue, key, value }) {
            (parentNode || treeData).forEach(ele => {
                if (ele.id === id) {
                    if (nodeValue) {
                        for (let _key in nodeValue) {
                            if (nodeValue[_key] === undefined) {
                                delete ele[_key];
                            } else {
                                ele[_key] = nodeValue[_key];
                            }
                        }
                    } else {
                        ele[key] = value;
                    }
                    return;
                } else {
                    if (ele.children) {
                        this.commit('layerTree/updataTreeNode', {
                            parentNode: ele.children,
                            id,
                            nodeValue,
                            key,
                            value
                        })
                    }
                }
            })
        },
        // 移除节点
        removeTreeNode({ treeData }, { id, parentNode }) {
            (parentNode || treeData).forEach((ele, index) => {
                if (ele.id === id) {
                    (parentNode || treeData).splice(index, 1)
                    return;
                } else {
                    if (ele.children) {
                        this.commit('layerTree/removeTreeNode', { id, parentNode: ele.children })
                    }
                }
            })
        }
    }
}