@sy-common/organize-select-help 1.0.0-beta.4 → 1.0.0-beta.42
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/package.json +3 -2
- package/readme.md +2 -1
- package/src/index.vue +1699 -184
- package/src/organize-tree.vue +362 -95
package/src/index.vue
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
<template>
|
|
2
|
-
|
|
2
|
+
<Modal
|
|
3
3
|
title=""
|
|
4
4
|
v-model="modal"
|
|
5
5
|
@on-ok="confirm"
|
|
@@ -7,132 +7,220 @@
|
|
|
7
7
|
width="1180"
|
|
8
8
|
:mask-closable="false"
|
|
9
9
|
class="modal-tree"
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
10
|
+
>
|
|
11
|
+
<div slot="header" class="header-text"><Icon type="md-information" class="icon-tip" />人员选择</div>
|
|
12
|
+
<div class="content-container">
|
|
13
|
+
<div class="tree-orig">
|
|
14
|
+
<div class="tab-content">
|
|
15
|
+
<Tabs v-if="computedTabName" v-model="activeTabName" @input="handleTabChange" >
|
|
16
|
+
<TabPane label="组织选择" name="org" v-if="name.includes('org')">
|
|
17
|
+
<div class="tab">
|
|
18
|
+
<span>组织搜索：</span>
|
|
19
|
+
<Select v-model="orgSearch" filterable :remote-method="getOrgListBySearch" @on-change="getOrgOption" :loading="loadingOrg" placeholder="请输入组织名称" style="width: 600px;" clearable>
|
|
20
|
+
<Option v-for="(option, index) in orgSearchList" :value="option.orgUnitId" :key="index">{{option.name}}</Option>
|
|
21
|
+
</Select>
|
|
22
|
+
<div class="tag-content" v-if="isQuickOpen && orgTagList.length > 0">
|
|
23
|
+
<span>快捷选择：</span>
|
|
24
|
+
<div class="custom-select-wrapper">
|
|
25
|
+
<Select
|
|
26
|
+
v-model="selectedOrgTagKey"
|
|
27
|
+
placeholder="请选择快捷标签"
|
|
28
|
+
transfer
|
|
29
|
+
clearable
|
|
30
|
+
@on-change="handleOrgTagSelect"
|
|
31
|
+
@on-clear="handleOrgTagClear"
|
|
32
|
+
style="width: 600px;"
|
|
33
|
+
:disabled="!orgTagList.length"
|
|
34
|
+
>
|
|
35
|
+
<Option
|
|
36
|
+
v-for="item in orgTagList"
|
|
37
|
+
:value="item.quickPickKey"
|
|
38
|
+
:key="item.quickPickKey"
|
|
39
|
+
:class="{ 'active-option': item.checked }"
|
|
40
|
+
>
|
|
41
|
+
{{ item.quickPickName }}
|
|
42
|
+
</Option>
|
|
43
|
+
<!-- 无数据提示 -->
|
|
44
|
+
<Option value="" v-if="!postTagList.length" disabled>
|
|
45
|
+
暂无快捷标签
|
|
46
|
+
</Option>
|
|
47
|
+
</Select>
|
|
48
|
+
</div>
|
|
49
|
+
</div>
|
|
50
|
+
<div class="tree">
|
|
51
|
+
<organizeTree @handleChange="getOrgList" ref="orgTree" :treeList="orgTree"></organizeTree>
|
|
52
|
+
</div>
|
|
53
|
+
<div class="bottom-select">
|
|
54
|
+
<CheckboxGroup v-model="includeLevelOrg">
|
|
55
|
+
<Checkbox label="01">
|
|
56
|
+
<span>包含下级组织节点</span>
|
|
57
|
+
</Checkbox>
|
|
58
|
+
</CheckboxGroup>
|
|
59
|
+
<Button type="primary" icon="md-add" @click="addOrgList">添加节点</Button>
|
|
60
|
+
</div>
|
|
61
|
+
</div>
|
|
62
|
+
</TabPane>
|
|
63
|
+
<TabPane label="岗位选择" name="post" v-if="name.includes('post')">
|
|
64
|
+
<div class="tab post">
|
|
65
|
+
<div class="left" style="height: 450px; overflow: hidden; position: relative; z-index: 1;">
|
|
66
|
+
<div class="scroll-container">
|
|
67
|
+
<div class="position-item"
|
|
68
|
+
v-for="item in positiontList"
|
|
69
|
+
:class="[selectedPositionId === item.positionId ? 'active' : '']"
|
|
70
|
+
:key="item.positionId"
|
|
71
|
+
@click="getPosionId(item)">
|
|
72
|
+
{{ item.positionName }} <!-- 无需修改模板，仅通过样式实现自动换行 -->
|
|
73
|
+
</div>
|
|
74
|
+
</div>
|
|
75
|
+
</div>
|
|
76
|
+
<div class="right">
|
|
77
|
+
<span>组织搜索：</span>
|
|
78
|
+
<Select v-model="postSearch" filterable :remote-method="getPostListBySearch" @on-change="getPostOption" placeholder="组织选择" :loading="loadingPost" clearable @on-clear="handlePostSearchClear" style="width: 365px;">
|
|
79
|
+
<Option v-for="(option, index) in postSearchList" :value="option.orgUnitId" :key="index">{{option.name}}</Option>
|
|
80
|
+
</Select>
|
|
81
|
+
<div class="tag-content" v-if="isQuickOpen && postTagList.length > 0">
|
|
20
82
|
<span>快捷选择：</span>
|
|
21
|
-
<div class="
|
|
22
|
-
<
|
|
83
|
+
<div class="custom-select-wrapper">
|
|
84
|
+
<Select
|
|
85
|
+
v-model="selectedPostTagKey"
|
|
86
|
+
placeholder="请选择快捷标签"
|
|
87
|
+
transfer
|
|
88
|
+
clearable
|
|
89
|
+
@on-change="handlePostTagSelect"
|
|
90
|
+
@on-clear="handlePostTagClear"
|
|
91
|
+
style="width: 365px;"
|
|
92
|
+
:disabled="!postTagList.length"
|
|
93
|
+
>
|
|
94
|
+
<Option
|
|
95
|
+
v-for="item in postTagList"
|
|
96
|
+
:value="item.quickPickKey"
|
|
97
|
+
:key="item.quickPickKey"
|
|
98
|
+
:class="{ 'active-option': item.checked }"
|
|
99
|
+
>
|
|
100
|
+
{{ item.quickPickName }}
|
|
101
|
+
</Option>
|
|
102
|
+
<!-- 无数据提示 -->
|
|
103
|
+
<Option value="" v-if="!postTagList.length" disabled>
|
|
104
|
+
暂无快捷标签
|
|
105
|
+
</Option>
|
|
106
|
+
</Select>
|
|
23
107
|
</div>
|
|
24
108
|
</div>
|
|
25
109
|
<div class="tree">
|
|
26
|
-
<organizeTree @handleChange="
|
|
110
|
+
<organizeTree @handleChange="getPostList" ref="postTree" :treeList="postTree"></organizeTree>
|
|
27
111
|
</div>
|
|
28
112
|
<div class="bottom-select">
|
|
29
|
-
<CheckboxGroup v-model="
|
|
113
|
+
<CheckboxGroup v-model="includeLevelPost">
|
|
30
114
|
<Checkbox label="01">
|
|
31
115
|
<span>包含下级组织节点</span>
|
|
32
116
|
</Checkbox>
|
|
33
117
|
</CheckboxGroup>
|
|
34
|
-
<Button type="primary" icon="md-add" @click="
|
|
118
|
+
<Button type="primary" icon="md-add" @click="addPostList">添加节点</Button>
|
|
35
119
|
</div>
|
|
36
120
|
</div>
|
|
37
|
-
</
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
<div class="
|
|
44
|
-
|
|
45
|
-
<
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
<div class="bottom-select">
|
|
55
|
-
<CheckboxGroup v-model="includeLevelPost">
|
|
56
|
-
<Checkbox label="01">
|
|
57
|
-
<span>包含下级组织节点</span>
|
|
58
|
-
</Checkbox>
|
|
59
|
-
</CheckboxGroup>
|
|
60
|
-
<Button type="primary" icon="md-add" @click="addPostList">添加节点</Button>
|
|
61
|
-
</div>
|
|
121
|
+
</div>
|
|
122
|
+
</TabPane>
|
|
123
|
+
<TabPane label="选择人员" name="staff" v-if="name.includes('staff')">
|
|
124
|
+
<div class="tab staff-left-right-layout">
|
|
125
|
+
<!-- 左侧：组织选择区域（限制高度） -->
|
|
126
|
+
<div class="staff-left-panel">
|
|
127
|
+
<div class="panel-title">组织选择</div>
|
|
128
|
+
<div class="tree staff-org-tree">
|
|
129
|
+
<organizeTree
|
|
130
|
+
@handleChange="getStaffList"
|
|
131
|
+
ref="staffTree"
|
|
132
|
+
:treeList="staffTree"
|
|
133
|
+
:showCheckbox="true"
|
|
134
|
+
:checkStrictly="true"
|
|
135
|
+
:autoExpandParent="true"
|
|
136
|
+
:isSingleSelect="true"
|
|
137
|
+
></organizeTree>
|
|
62
138
|
</div>
|
|
63
139
|
</div>
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
67
|
-
<
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
<
|
|
140
|
+
|
|
141
|
+
<div class="staff-right-panel">
|
|
142
|
+
<Input v-model="staffSearch" @on-enter="searchStaff" @on-search="searchStaff" search placeholder="搜索人员"/>
|
|
143
|
+
<div style="position:relative;">
|
|
144
|
+
<div class="tree staff-content" @scroll="handleScroll">
|
|
145
|
+
<div :class="['gust-item',item.checked && 'staff-active']"
|
|
146
|
+
v-for="(item, index) in staffAllList"
|
|
147
|
+
:key="`staff_${index}_${item.id}`"
|
|
148
|
+
@click="handlestaff(item)">
|
|
149
|
+
<Checkbox
|
|
150
|
+
v-model="item.checked"
|
|
151
|
+
class="staff-checkbox"
|
|
152
|
+
@click.stop="() => handlestaff(item)"
|
|
153
|
+
></Checkbox>
|
|
154
|
+
<div class="left-panel">{{item.name && item.name.slice(0,1) || ''}}</div>
|
|
155
|
+
<div class="right-panel">
|
|
156
|
+
<p>{{item.name}}</p>
|
|
157
|
+
<p>{{item.orgNodeName || item.orgUnitName}}</p>
|
|
158
|
+
</div>
|
|
159
|
+
<!-- <div class="checked-icon" v-show="item.checked">✔</div>-->
|
|
74
160
|
</div>
|
|
75
|
-
<
|
|
161
|
+
<p v-if="staffEnding" style="color:#CCCCCC;text-align: center">---我也是有底线的---</p>
|
|
76
162
|
</div>
|
|
163
|
+
<Spin v-if="loadingStaff" size="large" fix />
|
|
77
164
|
</div>
|
|
78
165
|
<div class="bottom-select">
|
|
79
166
|
<div>当前已选择 <span class="num">{{getCheckedStaff}}</span>人</div>
|
|
80
167
|
<Button type="primary" icon="md-add" @click="addStaffList">添加人员</Button>
|
|
81
168
|
</div>
|
|
82
169
|
</div>
|
|
83
|
-
</TabPane>
|
|
84
|
-
</Tabs>
|
|
85
|
-
</div>
|
|
86
|
-
<div class="form-content">
|
|
87
|
-
<p>已选择条件 <span class="num">（{{getCheckTypenum}}）</span></p>
|
|
88
|
-
<div class="node-list">
|
|
89
|
-
<!-- 组织节点条件：-->
|
|
90
|
-
<div>
|
|
91
|
-
<div class="group-box flex-r-bt">
|
|
92
|
-
<div>组织节点条件：</div>
|
|
93
|
-
<div class="clear-btn" @click="clearGroup">清除全部</div>
|
|
94
|
-
</div>
|
|
95
|
-
<div class="group-list-content">
|
|
96
|
-
<p class="list-item flex-r-bt" v-for="(item,index) in orgList" :ket="index">
|
|
97
|
-
<span>{{ item.title }}</span>
|
|
98
|
-
<img class="clear-icon" src="./assets/delete.png" alt="" @click="clearOrgByIndex(index)">
|
|
99
|
-
</p>
|
|
100
|
-
<p style="color:#CCCCCC" class="list-item" v-if="!orgList.length">未选择组织节点</p>
|
|
101
|
-
</div>
|
|
102
170
|
</div>
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
<p style="color:#CCCCCC" class="list-item" v-if="!postList.length">未选择组织节点+岗位条件</p>
|
|
115
|
-
</div>
|
|
171
|
+
</TabPane>
|
|
172
|
+
</Tabs>
|
|
173
|
+
</div>
|
|
174
|
+
<div class="form-content">
|
|
175
|
+
<p v-if="name.length > 1">已选择条件 <span class="num">（{{getCheckTypenum}}）</span></p>
|
|
176
|
+
<div class="node-list">
|
|
177
|
+
<!-- 组织节点条件：-->
|
|
178
|
+
<div v-if="name.includes('org')">
|
|
179
|
+
<div class="group-box flex-r-bt">
|
|
180
|
+
<div>组织节点条件：</div>
|
|
181
|
+
<div class="clear-btn" @click="clearGroup">清除全部</div>
|
|
116
182
|
</div>
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
<
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
183
|
+
<div class="group-list-content">
|
|
184
|
+
<p class="list-item flex-r-bt" v-for="(item,index) in orgList" :ket="index">
|
|
185
|
+
<span>{{ item.title }}</span>
|
|
186
|
+
<img class="clear-icon" src="./assets/delete.png" alt="" @click="clearOrgByIndex(index)">
|
|
187
|
+
</p>
|
|
188
|
+
<p style="color:#CCCCCC" class="list-item" v-if="!orgList.length">未选择组织节点</p>
|
|
189
|
+
</div>
|
|
190
|
+
</div>
|
|
191
|
+
<!-- 组织节点+岗位条件：//-->
|
|
192
|
+
<div v-if="name.includes('post')">
|
|
193
|
+
<div class="group-box flex-r-bt">
|
|
194
|
+
<div>岗位条件+组织节点：</div>
|
|
195
|
+
<div class="clear-btn" @click="clearPost">清除全部</div>
|
|
196
|
+
</div>
|
|
197
|
+
<div class="group-list-content">
|
|
198
|
+
<p class="list-item flex-r-bt" v-for="(item,index) in postList">
|
|
199
|
+
<span>{{item.positionName}}-{{item.title}}</span>
|
|
200
|
+
<img class="clear-icon" src="./assets/delete.png" alt="" @click="clearPostByIndex(index)">
|
|
201
|
+
</p>
|
|
202
|
+
<p style="color:#CCCCCC" class="list-item" v-if="!postList.length">未选择岗位条件+组织节点</p>
|
|
203
|
+
</div>
|
|
204
|
+
</div>
|
|
205
|
+
<!-- 直接选择人员：-->
|
|
206
|
+
<div v-if="name.includes('staff')">
|
|
207
|
+
<div class="group-box flex-r-bt">
|
|
208
|
+
<div>直接选择人员：</div>
|
|
209
|
+
<div class="clear-btn" @click="clearStaff">清除全部</div>
|
|
210
|
+
</div>
|
|
211
|
+
<div class="group-list-content">
|
|
212
|
+
<p class="list-item flex-r-bt" v-for="(item,index) in staffList" :key="item.userId">
|
|
213
|
+
<span>{{item.name}}</span>
|
|
214
|
+
<img class="clear-icon" src="./assets/delete.png" alt="" @click="clearStaffByIndex(index)">
|
|
215
|
+
</p>
|
|
216
|
+
<p style="color:#CCCCCC" class="list-item" v-if="!staffList.length">未选择直接选择人员</p>
|
|
130
217
|
</div>
|
|
131
218
|
</div>
|
|
132
219
|
</div>
|
|
133
220
|
</div>
|
|
134
221
|
</div>
|
|
135
|
-
</
|
|
222
|
+
</div>
|
|
223
|
+
</Modal>
|
|
136
224
|
</template>
|
|
137
225
|
<script>
|
|
138
226
|
import organizeTree from './organize-tree.vue'
|
|
@@ -147,44 +235,230 @@ export default {
|
|
|
147
235
|
},
|
|
148
236
|
data:{
|
|
149
237
|
type:Object,
|
|
150
|
-
default:{}
|
|
238
|
+
default:()=>{}
|
|
239
|
+
},
|
|
240
|
+
name:{
|
|
241
|
+
type:Array ,
|
|
242
|
+
default(){return ['org','post','staff']}
|
|
243
|
+
},
|
|
244
|
+
isQuickOpen:{
|
|
245
|
+
type: Boolean,
|
|
246
|
+
default: false
|
|
247
|
+
},
|
|
248
|
+
defaultOrgUnitId:{
|
|
249
|
+
type: String,
|
|
250
|
+
default: ''
|
|
151
251
|
}
|
|
152
252
|
},
|
|
153
253
|
data(){
|
|
154
254
|
return {
|
|
255
|
+
activeTabName: '',
|
|
256
|
+
tabName: '',
|
|
155
257
|
modal:false,
|
|
156
|
-
name:'name1',
|
|
157
258
|
dialogOpen:false,
|
|
158
259
|
orgSearch:'',
|
|
159
260
|
//组织--right-form
|
|
160
261
|
proOrgList:[],
|
|
161
262
|
includeLevelOrg:[],
|
|
162
263
|
orgList:[],
|
|
264
|
+
loadingOrg:false,
|
|
265
|
+
orgSearchList:[],
|
|
266
|
+
orgTree:[],
|
|
163
267
|
//岗位--form
|
|
268
|
+
postSearch:'',
|
|
164
269
|
proPostList:[],
|
|
165
270
|
postList:[],
|
|
271
|
+
loadingPost:false,
|
|
272
|
+
postSearchList:[],
|
|
166
273
|
includeLevelPost:[],
|
|
167
274
|
positiontList:[],
|
|
275
|
+
postTree:[],
|
|
168
276
|
//直接人员
|
|
169
277
|
staffSearch:'',
|
|
170
278
|
staffAllList:[],
|
|
171
279
|
staffList:[],
|
|
172
|
-
|
|
173
|
-
|
|
174
|
-
|
|
175
|
-
|
|
176
|
-
|
|
177
|
-
|
|
178
|
-
|
|
179
|
-
|
|
180
|
-
|
|
280
|
+
loadingStaff:false,
|
|
281
|
+
lastLoadingTime:0,
|
|
282
|
+
offset:0,
|
|
283
|
+
staffEnding:false,
|
|
284
|
+
parentOrgList: [],
|
|
285
|
+
orgTagList:[],
|
|
286
|
+
postTagList:[],
|
|
287
|
+
selectedPositionId: null, // 新增：岗位单选的选中状态存储
|
|
288
|
+
selectedOrgTagKey: '', // 存储选中标签的唯一标识
|
|
289
|
+
selectedPostTagKey: '', // 存储选中标签的唯一标识
|
|
290
|
+
//人员选择
|
|
291
|
+
staffTree:[],
|
|
292
|
+
staffTagList:[],
|
|
293
|
+
staffOrgList:[],
|
|
294
|
+
staffSearchList:[],
|
|
295
|
+
selectedStaffOrgId: '', // 新增：选中的组织节点ID
|
|
296
|
+
proStaffOrgList: [] // 新增：暂存选中的组织节点
|
|
181
297
|
}
|
|
182
298
|
},
|
|
299
|
+
created() {
|
|
300
|
+
console.log("this.name", this.name);
|
|
301
|
+
this.activeTabName = this.computedTabName;
|
|
302
|
+
console.log("this.activeTabName", this.activeTabName);
|
|
303
|
+
// 新增：初始化时强制触发一次Tab更新，确保DOM渲染
|
|
304
|
+
this.$nextTick(() => {
|
|
305
|
+
this.$forceUpdate();
|
|
306
|
+
});
|
|
307
|
+
},
|
|
183
308
|
mounted() {
|
|
309
|
+
this.queryTagList()
|
|
184
310
|
this.queryPositionList()
|
|
185
|
-
this.
|
|
311
|
+
this.initStaffOrgTree()
|
|
312
|
+
|
|
313
|
+
// 新增：mounted阶段再次确认activeTabName，确保Tab激活
|
|
314
|
+
this.$nextTick(() => {
|
|
315
|
+
this.activeTabName = this.computedTabName;
|
|
316
|
+
// 如果是staff Tab，主动触发初始化
|
|
317
|
+
if (this.activeTabName === 'staff') {
|
|
318
|
+
this.handleTabChange('staff');
|
|
319
|
+
}
|
|
320
|
+
});
|
|
321
|
+
console.log("传入的 name 数组：", this.name);
|
|
322
|
+
console.log("是否包含 staff：", this.name.includes('staff'));
|
|
323
|
+
console.log("最终激活的 Tab：", this.activeTabName);
|
|
186
324
|
},
|
|
187
325
|
methods:{
|
|
326
|
+
async initStaffOrgTree() {
|
|
327
|
+
try {
|
|
328
|
+
// 关键修复：初始化时重置选中状态
|
|
329
|
+
this.$set(this, 'selectedStaffOrgId', '');
|
|
330
|
+
this.proStaffOrgList = [];
|
|
331
|
+
|
|
332
|
+
const rootOrgId = this.defaultOrgUnitId || '';
|
|
333
|
+
let rootNode = null;
|
|
334
|
+
|
|
335
|
+
if (rootOrgId) {
|
|
336
|
+
const leafNode = await this.judgeNodeLeafe(rootOrgId);
|
|
337
|
+
const orgDetail = await this.queryOrgNodeDetail(rootOrgId);
|
|
338
|
+
rootNode = this.safeDeepCopy({
|
|
339
|
+
...orgDetail,
|
|
340
|
+
orgNodeName: orgDetail.orgNodeName || orgDetail.name,
|
|
341
|
+
leafNode,
|
|
342
|
+
expand: true,
|
|
343
|
+
parentOrgUnitId: orgDetail.parentOrgUnitId || orgDetail.parentId
|
|
344
|
+
});
|
|
345
|
+
} else {
|
|
346
|
+
const res = await ajax.get('/pub-manage-server/pub/personHelpBox/q/getOrgUnitList', {
|
|
347
|
+
params: { containsCurLevel: true }
|
|
348
|
+
});
|
|
349
|
+
if (res.data.code === 1) {
|
|
350
|
+
rootNode = res.data.data[0] || null;
|
|
351
|
+
if (rootNode) {
|
|
352
|
+
rootNode.expand = true;
|
|
353
|
+
rootNode.parentOrgUnitId = rootNode.parentId;
|
|
354
|
+
}
|
|
355
|
+
}
|
|
356
|
+
}
|
|
357
|
+
|
|
358
|
+
if (rootNode) {
|
|
359
|
+
let parentsList = await this.getParentOrgNodesByOrgUnitId(rootNode.orgUnitId);
|
|
360
|
+
const safeParents = this.safeDeepCopy(parentsList);
|
|
361
|
+
safeParents.forEach(node => {
|
|
362
|
+
node.expand = true;
|
|
363
|
+
node.parentOrgUnitId = node.parentId;
|
|
364
|
+
});
|
|
365
|
+
const tree = this.buildTree([...safeParents, rootNode]);
|
|
366
|
+
this.staffTree = this.safeDeepCopy(tree);
|
|
367
|
+
}
|
|
368
|
+
} catch (e) {
|
|
369
|
+
this.$Message.error("人员选择组织树初始化失败！");
|
|
370
|
+
console.error(e);
|
|
371
|
+
}
|
|
372
|
+
},
|
|
373
|
+
handlePostTagSelect(quickPickKey) {
|
|
374
|
+
// 清空暂存列表
|
|
375
|
+
this.proPostList = [];
|
|
376
|
+
// 找到选中的标签对象
|
|
377
|
+
const selectedItem = this.postTagList.find(
|
|
378
|
+
item => item.quickPickKey === quickPickKey
|
|
379
|
+
);
|
|
380
|
+
|
|
381
|
+
if (selectedItem) {
|
|
382
|
+
// 重置其他标签的选中状态
|
|
383
|
+
this.postTagList.forEach(tag => tag.checked = false);
|
|
384
|
+
// 触发原有的处理方法
|
|
385
|
+
this.fastChedkPost(selectedItem);
|
|
386
|
+
// 清空搜索框绑定的值
|
|
387
|
+
this.postSearch = '';
|
|
388
|
+
// 清空搜索结果列表
|
|
389
|
+
this.postSearchList = [];
|
|
390
|
+
}
|
|
391
|
+
},
|
|
392
|
+
handleOrgTagSelect(quickPickKey) {
|
|
393
|
+
// 清空暂存列表
|
|
394
|
+
this.proOrgList = [];
|
|
395
|
+
// 找到选中的标签对象
|
|
396
|
+
const selectedItem = this.orgTagList.find(
|
|
397
|
+
item => item.quickPickKey === quickPickKey
|
|
398
|
+
);
|
|
399
|
+
|
|
400
|
+
if (selectedItem) {
|
|
401
|
+
// 重置其他标签的选中状态
|
|
402
|
+
this.orgTagList.forEach(tag => tag.checked = false);
|
|
403
|
+
// 触发原有的处理方法
|
|
404
|
+
this.fastChedkOrg(selectedItem);
|
|
405
|
+
// 清空搜索框绑定的值
|
|
406
|
+
this.orgSearch = '';
|
|
407
|
+
// 清空搜索结果列表
|
|
408
|
+
this.orgSearchList = [];
|
|
409
|
+
}
|
|
410
|
+
},
|
|
411
|
+
handleOrgTagClear() {
|
|
412
|
+
this.selectedOrgTagKey = '';
|
|
413
|
+
// 重置所有标签的选中状态
|
|
414
|
+
this.orgTagList.forEach(tag => {
|
|
415
|
+
tag.checked = false;
|
|
416
|
+
});
|
|
417
|
+
|
|
418
|
+
// 3. 清空树选择状态和暂存列表
|
|
419
|
+
if (this.$refs.orgTree && this.orgSearchList) {
|
|
420
|
+
this.$refs.orgTree.initData();
|
|
421
|
+
}
|
|
422
|
+
// 4. 可选：添加清空提示
|
|
423
|
+
this.$Message.info("已清空快捷标签选择");
|
|
424
|
+
},
|
|
425
|
+
// 修正清空逻辑方法（与事件名称对应）
|
|
426
|
+
handlePostTagClear() {
|
|
427
|
+
// 1. 重置选中的标签key
|
|
428
|
+
this.selectedPostTagKey = '';
|
|
429
|
+
|
|
430
|
+
// 2. 重置所有标签的选中状态
|
|
431
|
+
this.postTagList.forEach(tag => {
|
|
432
|
+
tag.checked = false;
|
|
433
|
+
});
|
|
434
|
+
|
|
435
|
+
// 3. 清空树选择状态和暂存列表
|
|
436
|
+
if (this.$refs.postTree) {
|
|
437
|
+
this.$refs.postTree.initData();
|
|
438
|
+
this.proPostList = [];
|
|
439
|
+
}
|
|
440
|
+
|
|
441
|
+
// 4. 可选：添加清空提示
|
|
442
|
+
this.$Message.info("已清空快捷标签选择");
|
|
443
|
+
},
|
|
444
|
+
handlePostSearchClear() {
|
|
445
|
+
// 清空搜索框绑定的值
|
|
446
|
+
this.postSearch = '';
|
|
447
|
+
|
|
448
|
+
// 清空搜索结果列表
|
|
449
|
+
this.postSearchList = [];
|
|
450
|
+
|
|
451
|
+
// 重置树组件状态（与原有逻辑保持一致）
|
|
452
|
+
if (this.$refs.postTree) {
|
|
453
|
+
this.$refs.postTree.initData();
|
|
454
|
+
}
|
|
455
|
+
|
|
456
|
+
// 清空暂存列表
|
|
457
|
+
this.proPostList = [];
|
|
458
|
+
|
|
459
|
+
// 可选：添加清空提示
|
|
460
|
+
this.$Message.info("已清空组织选择搜索");
|
|
461
|
+
},
|
|
188
462
|
queryPositionList(){
|
|
189
463
|
ajax.get('/pub-manage-server/pub/personHelpBox/q/queryPositionList').then((res)=>{
|
|
190
464
|
if(res.data.code === 1){
|
|
@@ -194,38 +468,408 @@ export default {
|
|
|
194
468
|
}
|
|
195
469
|
})
|
|
196
470
|
},
|
|
197
|
-
|
|
198
|
-
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
|
|
202
|
-
|
|
471
|
+
getOrgListBySearch(query){
|
|
472
|
+
if (query !== '') {
|
|
473
|
+
this.loadingOrg = true;
|
|
474
|
+
this.getOrgUnitBySearchTerm(query,(res)=>{
|
|
475
|
+
this.loadingOrg = false
|
|
476
|
+
if(res.data.code === 1){
|
|
477
|
+
let resp = res.data.data?.items??[]
|
|
478
|
+
this.orgSearchList = resp
|
|
479
|
+
}else{
|
|
480
|
+
this.orgSearchList = []
|
|
481
|
+
this.$Message.error("获取组织节点列表失败！")
|
|
482
|
+
}
|
|
483
|
+
})
|
|
484
|
+
}else{
|
|
485
|
+
this.orgSearchList = [];
|
|
486
|
+
}
|
|
487
|
+
},
|
|
488
|
+
getPostListBySearch(query) {
|
|
489
|
+
if (query !== '') {
|
|
490
|
+
this.loadingPost = true;
|
|
491
|
+
this.getOrgUnitBySearchTerm(query, (res) => {
|
|
492
|
+
this.loadingPost = false;
|
|
493
|
+
if (res.data.code === 1) {
|
|
494
|
+
let resp = res.data.data?.items ?? [];
|
|
495
|
+
// 修复：岗位搜索结果深拷贝，避免引用污染
|
|
496
|
+
this.postSearchList = this.safeDeepCopy(resp);
|
|
497
|
+
} else {
|
|
498
|
+
this.postSearchList = [];
|
|
499
|
+
this.$Message.error("获取组织节点列表失败！");
|
|
500
|
+
}
|
|
501
|
+
});
|
|
502
|
+
} else {
|
|
503
|
+
// 修复：清空搜索时，同时清空树数据和暂存列表（与组织Tab一致）
|
|
504
|
+
this.postSearchList = [];
|
|
505
|
+
if (this.$refs.postTree) {
|
|
506
|
+
this.$refs.postTree.initData();
|
|
203
507
|
}
|
|
204
|
-
|
|
508
|
+
this.proPostList = []; // 清空岗位暂存列表
|
|
509
|
+
this.$set(this, 'postTree', []); // 清空岗位树数据
|
|
510
|
+
}
|
|
511
|
+
},
|
|
512
|
+
getOrgUnitBySearchTerm(query,callback){
|
|
513
|
+
ajax.get('/pub-manage-server/pub/personHelpBox/q/getOrgUnitBySearchTerm?searchTerm='+query).then((res)=>{callback(res)})
|
|
514
|
+
},
|
|
515
|
+
async getOrgOption(val) {
|
|
516
|
+
this.selectedOrgTagKey = '';
|
|
517
|
+
this.orgTagList.forEach(tag => {
|
|
518
|
+
tag.checked = false;
|
|
519
|
+
});
|
|
520
|
+
this.proOrgList = [];
|
|
521
|
+
if(!val) return this.$refs.orgTree.initData();
|
|
522
|
+
let item = this.orgSearchList.filter((item)=> item.orgUnitId === val).shift();
|
|
523
|
+
if (!item) return;
|
|
524
|
+
|
|
525
|
+
const leafNode = await this.judgeNodeLeafe(item.orgUnitId);
|
|
526
|
+
const ftem = this.safeDeepCopy({
|
|
527
|
+
...item,
|
|
528
|
+
orgNodeName: item.name,
|
|
529
|
+
parentOrgUnitId: item.parentId,
|
|
530
|
+
leafNode: leafNode
|
|
531
|
+
});
|
|
532
|
+
|
|
533
|
+
try{
|
|
534
|
+
let parentsList = await this.getParentOrgNodesByOrgUnitId(val);
|
|
535
|
+
// 对父节点列表进行安全拷贝
|
|
536
|
+
const safeParents = this.safeDeepCopy(parentsList);
|
|
537
|
+
let tree = this.buildTree([...safeParents, ftem]);
|
|
538
|
+
this.orgTree = this.safeDeepCopy(tree);
|
|
539
|
+
}catch(e){
|
|
540
|
+
this.$Message.error("获取组织节点列表失败！");
|
|
541
|
+
}
|
|
205
542
|
},
|
|
206
|
-
|
|
207
|
-
|
|
543
|
+
async getPostOption(val) {
|
|
544
|
+
// 1. 重置选中的标签key
|
|
545
|
+
this.selectedPostTagKey = '';
|
|
546
|
+
|
|
547
|
+
// 2. 重置所有标签的选中状态
|
|
548
|
+
this.postTagList.forEach(tag => {
|
|
549
|
+
tag.checked = false;
|
|
550
|
+
});
|
|
551
|
+
if (!val) {
|
|
552
|
+
// 修复：岗位树清空时，同时清空暂存列表和搜索框
|
|
553
|
+
if (this.$refs.postTree) {
|
|
554
|
+
this.$refs.postTree.initData();
|
|
555
|
+
}
|
|
556
|
+
this.proPostList = []; // 清空岗位暂存列表（与组织Tab保持一致）
|
|
557
|
+
this.postSearch = ''; // 清空搜索框
|
|
558
|
+
return;
|
|
559
|
+
}
|
|
560
|
+
|
|
561
|
+
let item = this.postSearchList.filter(item => item.orgUnitId === val).shift();
|
|
562
|
+
if (!item) return;
|
|
563
|
+
|
|
564
|
+
const leafNode = await this.judgeNodeLeafe(item.orgUnitId);
|
|
565
|
+
// 修复：岗位节点深拷贝，避免引用污染
|
|
566
|
+
const ftem = this.safeDeepCopy({
|
|
567
|
+
...item,
|
|
568
|
+
orgNodeName: item.name || `未命名组织(${item.orgUnitId})`,
|
|
569
|
+
parentOrgUnitId: item.parentId,
|
|
570
|
+
leafNode: leafNode
|
|
571
|
+
});
|
|
572
|
+
|
|
573
|
+
try {
|
|
574
|
+
let parentsList = await this.getParentOrgNodesByOrgUnitId(val);
|
|
575
|
+
const safeParents = this.safeDeepCopy(parentsList);
|
|
576
|
+
let tree = this.buildTree([...safeParents, ftem]);
|
|
577
|
+
// 修复：用$set确保岗位树数据响应式更新
|
|
578
|
+
this.$set(this, 'postTree', this.safeDeepCopy(tree));
|
|
579
|
+
|
|
580
|
+
// 修复：设置节点展开和选中（与组织Tab逻辑一致）
|
|
581
|
+
this.$nextTick(() => {
|
|
582
|
+
if (this.$refs.postTree && this.$refs.postTree.setCheckedNodes) {
|
|
583
|
+
this.$refs.postTree.setCheckedNodes([val]); // 选中当前节点
|
|
584
|
+
this.proPostList = [ftem]; // 同步暂存列表
|
|
585
|
+
}
|
|
586
|
+
});
|
|
587
|
+
} catch (e) {
|
|
588
|
+
this.$Message.error("获取组织节点列表失败！");
|
|
589
|
+
}
|
|
590
|
+
},
|
|
591
|
+
async getStaffOption(val) {
|
|
592
|
+
this.staffOrgList = [];
|
|
593
|
+
if(!val) return this.$refs.staffTree.initData();
|
|
594
|
+
let item = this.staffSearchList.filter((item)=> item.orgUnitId === val).shift();
|
|
595
|
+
if (!item) return;
|
|
596
|
+
|
|
597
|
+
const leafNode = await this.judgeNodeLeafe(item.orgUnitId);
|
|
598
|
+
const ftem = this.safeDeepCopy({
|
|
599
|
+
...item,
|
|
600
|
+
orgNodeName: item.name,
|
|
601
|
+
parentOrgUnitId: item.parentId,
|
|
602
|
+
leafNode: leafNode
|
|
603
|
+
});
|
|
604
|
+
|
|
605
|
+
try{
|
|
606
|
+
let parentsList = await this.getParentOrgNodesByOrgUnitId(val);
|
|
607
|
+
// 对父节点列表进行安全拷贝
|
|
608
|
+
const safeParents = this.safeDeepCopy(parentsList);
|
|
609
|
+
let tree = this.buildTree([...safeParents, ftem]);
|
|
610
|
+
this.staffTree = this.safeDeepCopy(tree);
|
|
611
|
+
}catch(e){
|
|
612
|
+
this.$Message.error("获取组织节点列表失败！");
|
|
613
|
+
}
|
|
208
614
|
},
|
|
209
|
-
|
|
210
|
-
|
|
615
|
+
getParentOrgNodesByOrgUnitId(val){
|
|
616
|
+
return new Promise((resolve,reject)=>{
|
|
617
|
+
ajax.get('/pub-manage-server/pub/personHelpBox/q/getParentOrgNodesByOrgUnitId?orgUnitId='+val).then((res)=>{
|
|
618
|
+
if(res.data.code === 1){
|
|
619
|
+
let parentsList = res.data?.data?.items??[]
|
|
620
|
+
resolve(parentsList)
|
|
621
|
+
}else{
|
|
622
|
+
reject(false)
|
|
623
|
+
}
|
|
624
|
+
})
|
|
625
|
+
})
|
|
211
626
|
},
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
|
|
217
|
-
|
|
218
|
-
|
|
627
|
+
judgeNodeLeafe(orgUnitId){
|
|
628
|
+
return new Promise((resolve,reject)=>{
|
|
629
|
+
ajax.get('/pub-manage-server/pub/personHelpBox/q/getOrgUnitList', { params:{
|
|
630
|
+
containsCurLevel:true,
|
|
631
|
+
orgUnitId:orgUnitId,
|
|
632
|
+
}
|
|
633
|
+
}).then((res)=>{
|
|
634
|
+
if(res.data.code === 1){
|
|
635
|
+
let treeList = res.data.data
|
|
636
|
+
if(treeList && treeList.length){
|
|
637
|
+
resolve(false)
|
|
638
|
+
}else{
|
|
639
|
+
resolve(true)
|
|
640
|
+
}
|
|
641
|
+
}else{
|
|
642
|
+
resolve(false)
|
|
643
|
+
}
|
|
644
|
+
})
|
|
219
645
|
})
|
|
220
|
-
|
|
646
|
+
},
|
|
647
|
+
buildTree(items) {
|
|
648
|
+
const map = {};
|
|
649
|
+
const roots = [];
|
|
650
|
+
// 对输入数据进行安全拷贝
|
|
651
|
+
const copiedItems = this.safeDeepCopy(items);
|
|
652
|
+
|
|
653
|
+
copiedItems.forEach(item => {
|
|
654
|
+
if (!item.orgUnitId) return; // 过滤无效节点
|
|
655
|
+
map[item.orgUnitId] = this.safeDeepCopy({
|
|
656
|
+
...item,
|
|
657
|
+
orgChildrenList: []
|
|
658
|
+
});
|
|
659
|
+
});
|
|
660
|
+
|
|
661
|
+
copiedItems.forEach(item => {
|
|
662
|
+
if (!item.orgUnitId || !map[item.orgUnitId]) return;
|
|
663
|
+
|
|
664
|
+
const node = map[item.orgUnitId];
|
|
665
|
+
if (!item.parentOrgUnitId || !map[item.parentOrgUnitId]) {
|
|
666
|
+
roots.push(node);
|
|
667
|
+
} else {
|
|
668
|
+
const parent = map[item.parentOrgUnitId];
|
|
669
|
+
parent.orgChildrenList.push(node);
|
|
670
|
+
}
|
|
671
|
+
});
|
|
672
|
+
return roots;
|
|
673
|
+
},
|
|
674
|
+
|
|
675
|
+
searchStaff(){
|
|
676
|
+
this.staffEnding = false;
|
|
677
|
+
this.offset = 0;
|
|
678
|
+
this.staffAllList = [];
|
|
679
|
+
// 关键修复：50ms延迟，解决极端情况下的异步更新问题
|
|
680
|
+
setTimeout(() => {
|
|
681
|
+
this.loadMore();
|
|
682
|
+
}, 50);
|
|
683
|
+
},
|
|
684
|
+
queryAllStaffList() {
|
|
685
|
+
const params = {
|
|
686
|
+
search: this.staffSearch,
|
|
687
|
+
offset: this.offset,
|
|
688
|
+
limit: 10
|
|
689
|
+
};
|
|
690
|
+
|
|
691
|
+
// 关键优化：实时监测选中状态，未选中时显式传递空字符串（而非不传递）
|
|
692
|
+
if (this.selectedStaffOrgId && typeof this.selectedStaffOrgId === 'string' && this.selectedStaffOrgId.trim()) {
|
|
693
|
+
params.orgUnitId = this.selectedStaffOrgId.trim();
|
|
694
|
+
} else {
|
|
695
|
+
// 未选中任何节点时，显式设置orgUnitId为空字符串
|
|
696
|
+
params.orgUnitId = '';
|
|
697
|
+
}
|
|
698
|
+
|
|
699
|
+
// 调试日志：查看最终传递的参数
|
|
700
|
+
console.log('人员查询接口参数:', params);
|
|
701
|
+
|
|
702
|
+
return new Promise((resolve, reject) => {
|
|
703
|
+
ajax.get('/pub-manage-server/pub/personHelpBox/q/queryAllStaffList', {
|
|
704
|
+
params: params
|
|
705
|
+
}).then((res) => {
|
|
706
|
+
if (res.data.code === 1) {
|
|
707
|
+
resolve(res.data.data);
|
|
708
|
+
} else {
|
|
709
|
+
reject(false);
|
|
710
|
+
}
|
|
711
|
+
}).catch((err) => {
|
|
712
|
+
reject(err);
|
|
713
|
+
});
|
|
714
|
+
});
|
|
715
|
+
},
|
|
716
|
+
handleScroll(e){
|
|
717
|
+
const { scrollTop, clientHeight, scrollHeight } = e.target;
|
|
718
|
+
if (scrollHeight - (scrollTop + clientHeight) < 50) {
|
|
719
|
+
this.loadMore();
|
|
720
|
+
}
|
|
721
|
+
},
|
|
722
|
+
async loadMore(){
|
|
723
|
+
let nowTime = Date.now()
|
|
724
|
+
if (this.loadingStaff || this.staffEnding || (nowTime - this.lastLoadingTime < 1000)) return
|
|
725
|
+
this.loadingStaff = true
|
|
726
|
+
try {
|
|
727
|
+
console.log("--触底加载---")
|
|
728
|
+
let res = await this.queryAllStaffList()
|
|
729
|
+
let list = res.rows;
|
|
730
|
+
list.map((item)=>item.checked=false)
|
|
731
|
+
this.staffAllList = this.staffAllList.concat(list)
|
|
732
|
+
this.offset += 10;
|
|
733
|
+
this.loadingStaff = false
|
|
734
|
+
this.lastLoadingTime = Date.now()
|
|
735
|
+
if(res.total===this.staffAllList.length){
|
|
736
|
+
this.staffEnding = true
|
|
737
|
+
}
|
|
738
|
+
}catch (e){
|
|
739
|
+
this.loadingStaff = false
|
|
740
|
+
this.lastLoadingTime = Date.now()
|
|
741
|
+
console.log(e)
|
|
742
|
+
}
|
|
743
|
+
},
|
|
744
|
+
getOrgList(data) {
|
|
745
|
+
// 过滤有效节点：仅要求orgUnitId（orgNodeName可选，用默认值兜底）
|
|
746
|
+
const validNodes = Array.isArray(data)
|
|
747
|
+
? data.filter(node => node.orgUnitId) // 仅校验orgUnitId（必选）
|
|
748
|
+
: [];
|
|
749
|
+
|
|
750
|
+
// 去重：基于orgUnitId避免重复
|
|
751
|
+
const uniqueNodes = validNodes.filter((node, index, self) =>
|
|
752
|
+
self.findIndex(item => item.orgUnitId === node.orgUnitId) === index
|
|
753
|
+
);
|
|
754
|
+
|
|
755
|
+
// 补全缺失字段，避免后续处理报错
|
|
756
|
+
const completeNodes = uniqueNodes.map(node => ({
|
|
757
|
+
...node,
|
|
758
|
+
orgNodeName: node.orgNodeName || node.name || `未命名组织(${node.orgUnitId})`,
|
|
759
|
+
orgUnitName: node.orgNodeName || node.name || `未命名组织(${node.orgUnitId})`
|
|
760
|
+
}));
|
|
761
|
+
|
|
762
|
+
// 安全深拷贝，确保数据响应式
|
|
763
|
+
this.proOrgList = this.safeDeepCopy(completeNodes);
|
|
764
|
+
},
|
|
765
|
+
|
|
766
|
+
getPostList(data) {
|
|
767
|
+
// 过滤有效节点：仅要求orgUnitId
|
|
768
|
+
const validNodes = Array.isArray(data)
|
|
769
|
+
? data.filter(node => node.orgUnitId)
|
|
770
|
+
: [];
|
|
771
|
+
|
|
772
|
+
// 去重：基于orgUnitId
|
|
773
|
+
const uniqueNodes = validNodes.filter((node, index, self) =>
|
|
774
|
+
self.findIndex(item => item.orgUnitId === node.orgUnitId) === index
|
|
775
|
+
);
|
|
776
|
+
|
|
777
|
+
// 补全缺失字段
|
|
778
|
+
const completeNodes = uniqueNodes.map(node => ({
|
|
779
|
+
...node,
|
|
780
|
+
orgNodeName: node.orgNodeName || node.name || `未命名组织(${node.orgUnitId})`,
|
|
781
|
+
orgUnitName: node.orgNodeName || node.name || `未命名组织(${node.orgUnitId})`
|
|
782
|
+
}));
|
|
783
|
+
|
|
784
|
+
// 覆盖暂存列表（而非concat，避免累积无效数据）
|
|
785
|
+
this.proPostList = this.safeDeepCopy(completeNodes);
|
|
786
|
+
},
|
|
787
|
+
getStaffList(data) {
|
|
788
|
+
if (!Array.isArray(data) || data.length === 0) {
|
|
789
|
+
this.proStaffOrgList = [];
|
|
790
|
+
// 强制清空并触发响应式更新
|
|
791
|
+
this.$set(this, 'selectedStaffOrgId', '');
|
|
792
|
+
// 立即触发搜索，确保orgUnitId参数实时更新为空
|
|
793
|
+
this.$nextTick(() => this.searchStaff());
|
|
794
|
+
return;
|
|
795
|
+
}
|
|
796
|
+
|
|
797
|
+
// 关键修复1：过滤仅含有效orgUnitId的节点，排除无效数据
|
|
798
|
+
const validNodes = data.filter(node =>
|
|
799
|
+
node.orgUnitId && typeof node.orgUnitId === 'string' // 确保orgUnitId存在且为字符串
|
|
800
|
+
);
|
|
801
|
+
|
|
802
|
+
if (validNodes.length === 0) {
|
|
803
|
+
this.$Message.warning("所选节点无效，请重新选择");
|
|
804
|
+
this.proStaffOrgList = [];
|
|
805
|
+
this.$set(this, 'selectedStaffOrgId', '');
|
|
806
|
+
// 立即触发搜索，更新参数为空
|
|
807
|
+
this.$nextTick(() => this.searchStaff());
|
|
808
|
+
return;
|
|
809
|
+
}
|
|
810
|
+
|
|
811
|
+
// 关键修复2：单选逻辑强化，仅保留最后一个有效选中节点
|
|
812
|
+
const currentNode = validNodes[validNodes.length - 1];
|
|
813
|
+
const currentOrgUnitId = currentNode.orgUnitId.trim(); // 去除空格，避免无效字符串
|
|
814
|
+
|
|
815
|
+
// 补全节点字段，确保orgUnitId绝对存在
|
|
816
|
+
const pureNode = this.safeDeepCopy({
|
|
817
|
+
...currentNode,
|
|
818
|
+
orgNodeName: currentNode.orgNodeName || currentNode.name || `未命名组织(${currentOrgUnitId})`,
|
|
819
|
+
orgUnitName: currentNode.orgNodeName || currentNode.name || `未命名组织(${currentOrgUnitId})`
|
|
820
|
+
});
|
|
821
|
+
|
|
822
|
+
// 清除子节点引用，避免循环引用导致的更新延迟
|
|
823
|
+
if (pureNode.orgChildrenList) pureNode.orgChildrenList = [];
|
|
824
|
+
if (pureNode.children) pureNode.children = [];
|
|
825
|
+
|
|
826
|
+
// 关键修复3：强制响应式更新，避免Vue数据延迟
|
|
827
|
+
this.$set(this, 'proStaffOrgList', [pureNode]);
|
|
828
|
+
this.$set(this, 'selectedStaffOrgId', currentOrgUnitId);
|
|
829
|
+
|
|
830
|
+
// 关键修复4：双重nextTick确保数据完全更新后再查询
|
|
831
|
+
this.$nextTick(() => {
|
|
832
|
+
if (this.selectedStaffOrgId !== currentOrgUnitId) {
|
|
833
|
+
this.$set(this, 'selectedStaffOrgId', currentOrgUnitId);
|
|
834
|
+
this.$nextTick(() => this.searchStaff());
|
|
835
|
+
} else {
|
|
836
|
+
this.searchStaff();
|
|
837
|
+
}
|
|
838
|
+
console.log('人员选择-当前选中orgUnitId:', this.selectedStaffOrgId); // 调试日志
|
|
839
|
+
});
|
|
840
|
+
},
|
|
841
|
+
|
|
842
|
+
addOrgList() {
|
|
843
|
+
// 过滤空节点（仅校验orgUnitId）
|
|
844
|
+
const validOrgList = this.proOrgList.filter(node => node.orgUnitId);
|
|
845
|
+
if (!validOrgList.length) return this.$Message.error("请先选择组织节点！");
|
|
846
|
+
|
|
847
|
+
let proOrgList = deepCopy(validOrgList);
|
|
848
|
+
proOrgList.forEach(item => {
|
|
849
|
+
// 用补全后的orgNodeName，避免空显示
|
|
850
|
+
item.title = this.includeLevelOrg.includes('01')
|
|
851
|
+
? `${item.orgNodeName}（包含下级组织节点）`
|
|
852
|
+
: item.orgNodeName;
|
|
853
|
+
item.id = this.includeLevelOrg.includes('01')
|
|
854
|
+
? (`01-${item.orgUnitId}`)
|
|
855
|
+
: (`00-${item.orgUnitId}`);
|
|
856
|
+
item.includeLevel = this.includeLevelOrg.includes('01');
|
|
857
|
+
});
|
|
858
|
+
|
|
859
|
+
// 去重合并
|
|
860
|
+
let list = this.orgList.concat(proOrgList);
|
|
221
861
|
let uniqueArray = list.filter((item, index, self) =>
|
|
222
|
-
index === self.findIndex(t =>
|
|
223
|
-
t.id === item.id // 基于id属性去重
|
|
224
|
-
))
|
|
862
|
+
index === self.findIndex(t => t.id === item.id)
|
|
225
863
|
);
|
|
226
|
-
this.orgList = uniqueArray
|
|
227
|
-
|
|
228
|
-
|
|
864
|
+
this.orgList = uniqueArray;
|
|
865
|
+
|
|
866
|
+
// 清空选中状态
|
|
867
|
+
if (this.$refs.orgTree && this.$refs.orgTree.clearAllChecked) {
|
|
868
|
+
this.$refs.orgTree.clearAllChecked(this.$refs.orgTree.data);
|
|
869
|
+
this.$refs.orgTree.$emit('handleChange', []);
|
|
870
|
+
}
|
|
871
|
+
this.$refs.orgTree.upDataTree();
|
|
872
|
+
this.proOrgList = [];
|
|
229
873
|
},
|
|
230
874
|
clearGroup(){
|
|
231
875
|
this.orgList = []
|
|
@@ -235,36 +879,47 @@ export default {
|
|
|
235
879
|
},
|
|
236
880
|
//岗位
|
|
237
881
|
getPosionId(item){
|
|
238
|
-
item.checked = !item.checked;
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
|
|
243
|
-
|
|
244
|
-
if(!
|
|
245
|
-
|
|
246
|
-
let
|
|
247
|
-
|
|
248
|
-
|
|
249
|
-
|
|
250
|
-
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
|
|
882
|
+
// item.checked = !item.checked;
|
|
883
|
+
this.selectedPositionId = item.positionId
|
|
884
|
+
},
|
|
885
|
+
addPostList() {
|
|
886
|
+
// 过滤空节点
|
|
887
|
+
const validPostList = this.proPostList.filter(node => node.orgUnitId);
|
|
888
|
+
if (!validPostList.length) return this.$Message.error("请选择组织节点！");
|
|
889
|
+
|
|
890
|
+
let checkedPosition = this.positiontList.find(item => item.positionId === this.selectedPositionId);
|
|
891
|
+
if (!checkedPosition) { return this.$Message.error("请选择岗位！"); }
|
|
892
|
+
|
|
893
|
+
let totalList = [];
|
|
894
|
+
validPostList.forEach(item => {
|
|
895
|
+
totalList.push({
|
|
896
|
+
...item,
|
|
897
|
+
...checkedPosition,
|
|
898
|
+
title: `${this.includeLevelPost.length ? (item.orgNodeName + '（包含下级组织节点）') : item.orgNodeName}`,
|
|
899
|
+
includeLevel: this.includeLevelPost.includes('01'),
|
|
900
|
+
id: this.includeLevelPost.includes('01')
|
|
901
|
+
? (`01-${checkedPosition.positionId}-${item.orgUnitId}`)
|
|
902
|
+
: (`00-${checkedPosition.positionId}-${item.orgUnitId}`),
|
|
903
|
+
});
|
|
904
|
+
});
|
|
905
|
+
|
|
906
|
+
// 去重合并
|
|
907
|
+
let list = this.postList.concat(totalList);
|
|
259
908
|
let uniqueArray = list.filter((item, index, self) =>
|
|
260
|
-
index === self.findIndex(t =>
|
|
261
|
-
t.id === item.id // 基于id属性去重
|
|
262
|
-
))
|
|
909
|
+
index === self.findIndex(t => t.id === item.id)
|
|
263
910
|
);
|
|
264
|
-
this.postList = uniqueArray
|
|
265
|
-
|
|
266
|
-
|
|
267
|
-
this.
|
|
911
|
+
this.postList = uniqueArray;
|
|
912
|
+
|
|
913
|
+
// 清空选中状态
|
|
914
|
+
if (this.$refs.postTree && this.$refs.postTree.clearAllChecked) {
|
|
915
|
+
this.$refs.postTree.clearAllChecked(this.$refs.postTree.data);
|
|
916
|
+
this.$refs.postTree.$emit('handleChange', []);
|
|
917
|
+
}
|
|
918
|
+
this.$refs.postTree.upDataTree();
|
|
919
|
+
this.proPostList = [];
|
|
920
|
+
this.selectedPositionId = null;
|
|
921
|
+
// this.$refs.postTree.initData();
|
|
922
|
+
this.selectedPostTagKey = '';
|
|
268
923
|
},
|
|
269
924
|
clearPost(){
|
|
270
925
|
this.postList= []
|
|
@@ -274,15 +929,20 @@ export default {
|
|
|
274
929
|
},
|
|
275
930
|
//staff
|
|
276
931
|
addStaffList(){
|
|
277
|
-
let staffList = this.staffAllList.filter((item)=>item.checked
|
|
278
|
-
|
|
279
|
-
|
|
280
|
-
|
|
281
|
-
|
|
282
|
-
|
|
932
|
+
let staffList = this.staffAllList.filter((item)=>item.checked===true);
|
|
933
|
+
if (!staffList.length) {
|
|
934
|
+
this.$Message.error("请选择人员");
|
|
935
|
+
return;
|
|
936
|
+
}
|
|
937
|
+
// 关键优化：基于item.id去重，不修改原数据字段，仅过滤重复项
|
|
938
|
+
let uniqueStaffList = staffList.filter(newItem =>
|
|
939
|
+
// 检查右侧条件区域（staffList）是否已有该人员，避免重复添加
|
|
940
|
+
!this.staffList.some(existItem => existItem.userId === newItem.userId)
|
|
283
941
|
);
|
|
284
|
-
|
|
285
|
-
this.
|
|
942
|
+
// 合并去重后的列表
|
|
943
|
+
this.staffList = this.staffList.concat(uniqueStaffList);
|
|
944
|
+
// 清空选中状态
|
|
945
|
+
this.staffAllList.forEach(item => item.checked = false);
|
|
286
946
|
},
|
|
287
947
|
handlestaff(item){
|
|
288
948
|
item.checked=!item.checked
|
|
@@ -294,17 +954,583 @@ export default {
|
|
|
294
954
|
this.staffList.splice(index,1)
|
|
295
955
|
},
|
|
296
956
|
confirm(){
|
|
297
|
-
|
|
957
|
+
const v = {
|
|
298
958
|
orgList:this.orgList,
|
|
299
959
|
postList:this.postList,
|
|
300
960
|
staffList:this.staffList
|
|
301
|
-
}
|
|
961
|
+
}
|
|
962
|
+
this.$emit('confirm',deepCopy(v))
|
|
302
963
|
},
|
|
303
|
-
visibleChange(val){
|
|
304
|
-
this.$emit('input',val);
|
|
964
|
+
visibleChange(val) {
|
|
965
|
+
this.$emit('input', val);
|
|
966
|
+
if (val) {
|
|
967
|
+
this.initStaffList()
|
|
968
|
+
} else {
|
|
969
|
+
this.staffEnding = false;
|
|
970
|
+
this.offset = 0;
|
|
971
|
+
this.staffAllList = [];
|
|
972
|
+
this.$set(this, 'selectedStaffOrgId', '');
|
|
973
|
+
}
|
|
974
|
+
},
|
|
975
|
+
initStaffList() {
|
|
976
|
+
this.staffEnding = false;
|
|
977
|
+
this.offset = 0;
|
|
978
|
+
this.staffAllList = [];
|
|
979
|
+
// 初始化时确保selectedStaffOrgId状态正确
|
|
980
|
+
if (this.tabName === 'staff' && (!this.selectedStaffOrgId || this.selectedStaffOrgId.trim())) {
|
|
981
|
+
this.$set(this, 'selectedStaffOrgId', '');
|
|
982
|
+
}
|
|
983
|
+
this.loadMore(); // 打开帮助框后，再发起第一次请求
|
|
305
984
|
},
|
|
985
|
+
// 处理Tab切换，同步更新tabName
|
|
986
|
+
handleTabChange(tabName) {
|
|
987
|
+
// 修复：先强制更新activeTabName，再触发nextTick
|
|
988
|
+
this.$set(this, 'activeTabName', tabName);
|
|
989
|
+
this.$nextTick(() => {
|
|
990
|
+
this.$forceUpdate();
|
|
991
|
+
if (tabName === 'staff') {
|
|
992
|
+
this.$set(this, 'selectedStaffOrgId', '');
|
|
993
|
+
this.proStaffOrgList = [];
|
|
994
|
+
if (this.$refs.staffTree) {
|
|
995
|
+
this.$refs.staffTree.clearAllChecked(this.$refs.staffTree.data);
|
|
996
|
+
this.$refs.staffTree.$emit('handleChange', []);
|
|
997
|
+
}
|
|
998
|
+
this.$nextTick(() => this.searchStaff());
|
|
999
|
+
} else if (tabName === 'post' && this.$refs.postTree && this.proPostList.length === 0) {
|
|
1000
|
+
this.proPostList = [];
|
|
1001
|
+
this.$refs.postTree.initData();
|
|
1002
|
+
}
|
|
1003
|
+
});
|
|
1004
|
+
},
|
|
1005
|
+
async fastChedkOrg(item) {
|
|
1006
|
+
// 1. 改用组织 Tab 专属标签列表判断
|
|
1007
|
+
if (!this.orgTagList.length) {
|
|
1008
|
+
this.$Message.warning("快捷选择标签正在加载中，请稍后");
|
|
1009
|
+
return;
|
|
1010
|
+
}
|
|
1011
|
+
const treeRef = this.$refs.orgTree;
|
|
1012
|
+
const proListKey = 'proOrgList';
|
|
1013
|
+
const treeDataKey = 'orgTree';
|
|
1014
|
+
this[proListKey] = [];
|
|
1015
|
+
if (treeRef) await treeRef.initData();
|
|
1016
|
+
if (!treeRef) {
|
|
1017
|
+
this.$Message.error("组织树组件未初始化，请稍后再试");
|
|
1018
|
+
item.checked = !item.checked;
|
|
1019
|
+
return;
|
|
1020
|
+
}
|
|
1021
|
+
|
|
1022
|
+
// 2. 清空组织 Tab 标签选中状态（仅操作 orgTagList）
|
|
1023
|
+
this.orgTagList.forEach(tag => {
|
|
1024
|
+
tag.checked = false;
|
|
1025
|
+
});
|
|
1026
|
+
|
|
1027
|
+
// 3. 后续逻辑保持不变，仅操作当前 item（属于 orgTagList）
|
|
1028
|
+
const isCurrentlyChecked = item.checked;
|
|
1029
|
+
if (!isCurrentlyChecked) {
|
|
1030
|
+
item.checked = true;
|
|
1031
|
+
}
|
|
1032
|
+
|
|
1033
|
+
if (!item.checked) {
|
|
1034
|
+
this.$Message.info("已取消该快捷选择");
|
|
1035
|
+
return;
|
|
1036
|
+
}
|
|
1037
|
+
|
|
1038
|
+
try {
|
|
1039
|
+
await this.querySpecificParam(item, true, treeRef, proListKey, treeDataKey);
|
|
1040
|
+
} catch (error) {
|
|
1041
|
+
this.$Message.error(`快捷选择处理失败：${error.message.slice(0, 50)}`);
|
|
1042
|
+
item.checked = !item.checked;
|
|
1043
|
+
}
|
|
1044
|
+
},
|
|
1045
|
+
async fastChedkPost(item) {
|
|
1046
|
+
// 1. 改用岗位 Tab 专属标签列表判断
|
|
1047
|
+
if (!this.postTagList.length) {
|
|
1048
|
+
this.$Message.warning("快捷选择标签正在加载中，请稍后");
|
|
1049
|
+
return;
|
|
1050
|
+
}
|
|
1051
|
+
|
|
1052
|
+
const isOrgTab = this.tabName === 'org';
|
|
1053
|
+
const treeRef = isOrgTab ? this.$refs.orgTree : this.$refs.postTree;
|
|
1054
|
+
const proListKey = isOrgTab ? 'proOrgList' : 'proPostList';
|
|
1055
|
+
const treeDataKey = isOrgTab ? 'orgTree' : 'postTree';
|
|
1056
|
+
|
|
1057
|
+
this[proListKey] = [];
|
|
1058
|
+
const isCurrentlyChecked = item.checked;
|
|
1059
|
+
if (treeRef) await treeRef.initData();
|
|
1060
|
+
|
|
1061
|
+
// 2. 清空岗位 Tab 标签选中状态（仅操作 postTagList）
|
|
1062
|
+
this.postTagList.forEach(tag => {
|
|
1063
|
+
tag.checked = false;
|
|
1064
|
+
});
|
|
1065
|
+
|
|
1066
|
+
// 3. 后续逻辑保持不变，仅操作当前 item（属于 postTagList）
|
|
1067
|
+
if (!isCurrentlyChecked) {
|
|
1068
|
+
item.checked = true;
|
|
1069
|
+
}
|
|
1070
|
+
|
|
1071
|
+
if (!item.checked) {
|
|
1072
|
+
this.$Message.info("已取消该快捷选择");
|
|
1073
|
+
return;
|
|
1074
|
+
}
|
|
1075
|
+
|
|
1076
|
+
try {
|
|
1077
|
+
await this.querySpecificParam(item, isOrgTab, treeRef, proListKey, treeDataKey);
|
|
1078
|
+
} catch (error) {
|
|
1079
|
+
this.$Message.error(`快捷选择处理失败：${error.message.slice(0, 50)}`);
|
|
1080
|
+
item.checked = !item.checked;
|
|
1081
|
+
}
|
|
1082
|
+
},
|
|
1083
|
+
queryTagList() {
|
|
1084
|
+
ajax.get('/pub-manage-server/pub/helpBoxTag/q/queryQuickPickTags').then((res) => {
|
|
1085
|
+
if (res.data.code === 1) {
|
|
1086
|
+
let baseTagList = res.data.data || [];
|
|
1087
|
+
// 组织 Tab 标签：深拷贝并初始化选中状态
|
|
1088
|
+
this.orgTagList = this.safeDeepCopy(baseTagList).map(item => ({
|
|
1089
|
+
...item,
|
|
1090
|
+
checked: false // 独立选中状态
|
|
1091
|
+
}));
|
|
1092
|
+
// 岗位 Tab 标签：深拷贝并初始化选中状态（与组织 Tab 完全独立）
|
|
1093
|
+
this.postTagList = this.safeDeepCopy(baseTagList).map(item => ({
|
|
1094
|
+
...item,
|
|
1095
|
+
checked: false // 独立选中状态
|
|
1096
|
+
}));
|
|
1097
|
+
}
|
|
1098
|
+
});
|
|
1099
|
+
},
|
|
1100
|
+
|
|
1101
|
+
querySpecificParam: function (item, isOrgTab, treeRef, proListKey, treeDataKey) {
|
|
1102
|
+
return new Promise((resolve, reject) => {
|
|
1103
|
+
// 取消选中时处理（仅当手动点击已选中的标签时触发）
|
|
1104
|
+
if (!item.checked) {
|
|
1105
|
+
if (treeRef && treeRef.initData) {
|
|
1106
|
+
treeRef.initData(); // 清空对应树组件
|
|
1107
|
+
}
|
|
1108
|
+
this[proListKey] = []; // 清空对应暂存列表
|
|
1109
|
+
this.$Message.info("已取消该快捷选择");
|
|
1110
|
+
resolve();
|
|
1111
|
+
return;
|
|
1112
|
+
}
|
|
1113
|
+
|
|
1114
|
+
// 请求快捷选择对应的orgUnitId列表
|
|
1115
|
+
ajax.get(`/pub-manage-server/pub/helpBoxTag/q/querySpecificParam?quickPickKey=${item.quickPickKey}`)
|
|
1116
|
+
.then(async (res) => {
|
|
1117
|
+
if (res.data.code !== 1) {
|
|
1118
|
+
this.$Message.error("获取快捷选择配置失败");
|
|
1119
|
+
item.checked = !item.checked;
|
|
1120
|
+
reject(new Error("获取配置失败"));
|
|
1121
|
+
return;
|
|
1122
|
+
}
|
|
1123
|
+
|
|
1124
|
+
const orgUnitIds = res.data.data?.param || [];
|
|
1125
|
+
const safeOrgUnitIds = Array.isArray(orgUnitIds) ? orgUnitIds : [];
|
|
1126
|
+
if (safeOrgUnitIds.length === 0) {
|
|
1127
|
+
this.$Message.warning("该快捷选择未配置任何组织节点");
|
|
1128
|
+
item.checked = !item.checked;
|
|
1129
|
+
reject(new Error("无配置节点"));
|
|
1130
|
+
return;
|
|
1131
|
+
}
|
|
1132
|
+
|
|
1133
|
+
// 校验树组件是否存在（通用校验）
|
|
1134
|
+
if (!treeRef) {
|
|
1135
|
+
this.$Message.error("树组件未初始化");
|
|
1136
|
+
item.checked = !item.checked;
|
|
1137
|
+
reject(new Error("树组件不存在"));
|
|
1138
|
+
return;
|
|
1139
|
+
}
|
|
1140
|
+
const originalTreeData = treeRef.data && treeRef.data.length ? this.safeDeepCopy(treeRef.data) : [];
|
|
1141
|
+
const matchedNodes = [];
|
|
1142
|
+
|
|
1143
|
+
// 批量处理每个orgUnitId（循环逻辑不变，通用处理）
|
|
1144
|
+
for (const orgUnitId of safeOrgUnitIds) {
|
|
1145
|
+
try {
|
|
1146
|
+
// 节点详情查询（复用原有方法）
|
|
1147
|
+
let currentNode = await this.queryOrgNodeDetail(orgUnitId);
|
|
1148
|
+
if (!currentNode || !currentNode.orgUnitId) {
|
|
1149
|
+
this.$Message.warning(`节点【${orgUnitId}】数据异常，跳过处理`);
|
|
1150
|
+
continue;
|
|
1151
|
+
}
|
|
1152
|
+
|
|
1153
|
+
// 循环引用检测与处理（复用原有方法）
|
|
1154
|
+
const cycle = this.detectCircularReferences(currentNode);
|
|
1155
|
+
if (cycle) {
|
|
1156
|
+
this.$Message.warning(`节点【${orgUnitId}】存在循环引用，已自动修复`);
|
|
1157
|
+
currentNode = this.safeDeepCopy(currentNode);
|
|
1158
|
+
}
|
|
1159
|
+
|
|
1160
|
+
// 节点名称默认值处理（复用原有逻辑）
|
|
1161
|
+
currentNode.orgNodeName = currentNode.orgNodeName || currentNode.orgUnitName || `未命名组织(${orgUnitId})`;
|
|
1162
|
+
currentNode.orgUnitName = currentNode.orgNodeName;
|
|
1163
|
+
|
|
1164
|
+
// 节点是否已在树中检测（复用原有方法）
|
|
1165
|
+
const nodeInTree = this.findNodeInTree(originalTreeData, orgUnitId);
|
|
1166
|
+
if (nodeInTree) {
|
|
1167
|
+
if (this.detectCircularReferences(nodeInTree)) {
|
|
1168
|
+
this.$Message.warning(`树中节点【${orgUnitId}】存在循环引用，已跳过`);
|
|
1169
|
+
continue;
|
|
1170
|
+
}
|
|
1171
|
+
matchedNodes.push(nodeInTree);
|
|
1172
|
+
continue;
|
|
1173
|
+
}
|
|
1174
|
+
|
|
1175
|
+
// 父节点追溯与节点链挂载（修复：使用当前Tab的树数据originalTreeData，而非固定orgTree）
|
|
1176
|
+
let targetParent = null;
|
|
1177
|
+
let nodeChain = [currentNode];
|
|
1178
|
+
const MAX_DEPTH = 8;
|
|
1179
|
+
let depth = 0;
|
|
1180
|
+
let lastParentId = '';
|
|
1181
|
+
|
|
1182
|
+
while (!targetParent && depth < MAX_DEPTH) {
|
|
1183
|
+
const parentId = currentNode.parentOrgUnitId;
|
|
1184
|
+
if (!parentId || typeof parentId !== 'string' || parentId === lastParentId) {
|
|
1185
|
+
break;
|
|
1186
|
+
}
|
|
1187
|
+
lastParentId = parentId;
|
|
1188
|
+
|
|
1189
|
+
const parentNode = await this.queryOrgNodeDetail(parentId);
|
|
1190
|
+
if (!parentNode || !parentNode.orgUnitId) {
|
|
1191
|
+
break;
|
|
1192
|
+
}
|
|
1193
|
+
|
|
1194
|
+
if (this.detectCircularReferences(parentNode)) {
|
|
1195
|
+
this.$Message.warning(`父节点【${parentId}】存在循环引用，已跳过`);
|
|
1196
|
+
break;
|
|
1197
|
+
}
|
|
1198
|
+
|
|
1199
|
+
parentNode.orgNodeName = parentNode.orgNodeName || parentNode.orgUnitName || `未命名组织(${parentId})`;
|
|
1200
|
+
// 修复：查询父节点是否在当前Tab的树数据中（originalTreeData），而非固定orgTree
|
|
1201
|
+
const parentInTree = this.findNodeInTree(originalTreeData, parentNode.orgUnitId);
|
|
1202
|
+
|
|
1203
|
+
if (parentInTree) {
|
|
1204
|
+
targetParent = parentInTree;
|
|
1205
|
+
break;
|
|
1206
|
+
}
|
|
1207
|
+
|
|
1208
|
+
nodeChain.unshift(parentNode);
|
|
1209
|
+
currentNode = parentNode;
|
|
1210
|
+
depth++;
|
|
1211
|
+
}
|
|
1212
|
+
|
|
1213
|
+
// 节点链挂载（复用原有方法）
|
|
1214
|
+
if (targetParent) {
|
|
1215
|
+
let currentMountParent = targetParent;
|
|
1216
|
+
for (const node of nodeChain) {
|
|
1217
|
+
const formattedNode = this.safeDeepCopy({
|
|
1218
|
+
...node,
|
|
1219
|
+
leafNode: await this.judgeNodeLeafe(node.orgUnitId),
|
|
1220
|
+
expand: true,
|
|
1221
|
+
checked: false,
|
|
1222
|
+
orgChildrenList: [],
|
|
1223
|
+
children: []
|
|
1224
|
+
});
|
|
1225
|
+
|
|
1226
|
+
if (!Array.isArray(currentMountParent.orgChildrenList)) {
|
|
1227
|
+
currentMountParent.orgChildrenList = [];
|
|
1228
|
+
currentMountParent.children = [];
|
|
1229
|
+
}
|
|
1230
|
+
|
|
1231
|
+
const isDuplicate = currentMountParent.orgChildrenList.some(
|
|
1232
|
+
child => child.orgUnitId === formattedNode.orgUnitId
|
|
1233
|
+
);
|
|
1234
|
+
if (!isDuplicate) {
|
|
1235
|
+
currentMountParent.orgChildrenList.push(formattedNode);
|
|
1236
|
+
currentMountParent.leafNode = false;
|
|
1237
|
+
}
|
|
1238
|
+
|
|
1239
|
+
currentMountParent = currentMountParent.orgChildrenList.find(
|
|
1240
|
+
child => child.orgUnitId === formattedNode.orgUnitId
|
|
1241
|
+
) || formattedNode;
|
|
1242
|
+
}
|
|
1243
|
+
|
|
1244
|
+
const mountedTarget = this.findNodeInTree(originalTreeData, orgUnitId);
|
|
1245
|
+
if (mountedTarget) {
|
|
1246
|
+
matchedNodes.push(mountedTarget);
|
|
1247
|
+
}
|
|
1248
|
+
}
|
|
1249
|
+
|
|
1250
|
+
} catch (error) {
|
|
1251
|
+
this.$Message.error(`处理节点【${orgUnitId}】失败：${error.message.slice(0, 50)}`);
|
|
1252
|
+
continue;
|
|
1253
|
+
}
|
|
1254
|
+
}
|
|
1255
|
+
|
|
1256
|
+
// 最终数据赋值（根据Tab类型区分，核心统一逻辑）
|
|
1257
|
+
|
|
1258
|
+
if (matchedNodes.length > 0) {
|
|
1259
|
+
// 同步暂存列表（组织proOrgList/岗位proPostList）
|
|
1260
|
+
this[proListKey] = matchedNodes;
|
|
1261
|
+
const finalTreeData = this.safeDeepCopy(originalTreeData);
|
|
1262
|
+
// 响应式更新对应树数据（组织orgTree/岗位postTree）
|
|
1263
|
+
this.$set(this, treeDataKey, finalTreeData);
|
|
1264
|
+
|
|
1265
|
+
await this.$nextTick(async () => {
|
|
1266
|
+
// 更新树组件数据（通用逻辑）
|
|
1267
|
+
if (treeRef.updateTreeData) {
|
|
1268
|
+
treeRef.updateTreeData(this.safeDeepCopy(finalTreeData));
|
|
1269
|
+
} else {
|
|
1270
|
+
treeRef.data = this.safeDeepCopy(finalTreeData);
|
|
1271
|
+
}
|
|
1272
|
+
|
|
1273
|
+
// 设置树选中状态（通用逻辑）
|
|
1274
|
+
const safeNodeIds = matchedNodes.map(node => node.orgUnitId);
|
|
1275
|
+
if (treeRef.setCheckedNodes) {
|
|
1276
|
+
treeRef.setCheckedNodes([]);
|
|
1277
|
+
treeRef.setCheckedNodes(safeNodeIds);
|
|
1278
|
+
treeRef.handleChange(matchedNodes); // 触发子组件选中事件
|
|
1279
|
+
} else {
|
|
1280
|
+
this.updateTreeNodesStatus(
|
|
1281
|
+
finalTreeData,
|
|
1282
|
+
new Set(safeNodeIds),
|
|
1283
|
+
new Set(safeNodeIds)
|
|
1284
|
+
);
|
|
1285
|
+
treeRef.handleChange(matchedNodes);
|
|
1286
|
+
}
|
|
1287
|
+
|
|
1288
|
+
// 提示信息（通用逻辑）
|
|
1289
|
+
this.$Message.success(`成功选中${matchedNodes.length}个组织节点`);
|
|
1290
|
+
});
|
|
1291
|
+
} else {
|
|
1292
|
+
this.$Message.warning("未找到任何可匹配的组织节点");
|
|
1293
|
+
item.checked = !item.checked;
|
|
1294
|
+
}
|
|
1295
|
+
resolve();
|
|
1296
|
+
})
|
|
1297
|
+
.catch((error) => {
|
|
1298
|
+
const errMsg = error.message || '网络异常';
|
|
1299
|
+
this.$Message.error(`快捷选择失败：${errMsg.slice(0, 50)}`);
|
|
1300
|
+
item.checked = !item.checked;
|
|
1301
|
+
reject(error);
|
|
1302
|
+
});
|
|
1303
|
+
});
|
|
1304
|
+
},
|
|
1305
|
+
|
|
1306
|
+
// 新增：移除树数据中的 parent 引用，避免子组件处理时形成循环
|
|
1307
|
+
removeParentReferences(treeData) {
|
|
1308
|
+
if (!Array.isArray(treeData)) return;
|
|
1309
|
+
treeData.forEach(node => {
|
|
1310
|
+
// 删除可能存在的 parent 引用（如果节点有此属性）
|
|
1311
|
+
if (node.parent) delete node.parent;
|
|
1312
|
+
// 递归处理子节点
|
|
1313
|
+
if (Array.isArray(node.orgChildrenList)) {
|
|
1314
|
+
this.removeParentReferences(node.orgChildrenList);
|
|
1315
|
+
}
|
|
1316
|
+
if (Array.isArray(node.children)) {
|
|
1317
|
+
this.removeParentReferences(node.children);
|
|
1318
|
+
}
|
|
1319
|
+
});
|
|
1320
|
+
},
|
|
1321
|
+
// 在 methods 中添加循环引用检测工具函数
|
|
1322
|
+
detectCircularReferences(obj, path = [], visited = new Map()) {
|
|
1323
|
+
if (obj === null || typeof obj !== 'object') return null;
|
|
1324
|
+
|
|
1325
|
+
if (visited.has(obj)) {
|
|
1326
|
+
return { path: [...path, visited.get(obj)], node: obj };
|
|
1327
|
+
}
|
|
1328
|
+
|
|
1329
|
+
visited.set(obj, Array.isArray(obj) ? 'Array' : `Object(${obj.orgUnitId || 'unknown'})`);
|
|
1330
|
+
|
|
1331
|
+
const keys = Array.isArray(obj) ? obj.map((_, i) => i) : Object.keys(obj);
|
|
1332
|
+
for (const key of keys) {
|
|
1333
|
+
const value = obj[key];
|
|
1334
|
+
const newPath = [...path, key];
|
|
1335
|
+
if (value && typeof value === 'object') {
|
|
1336
|
+
const cycle = this.detectCircularReferences(value, newPath, visited);
|
|
1337
|
+
if (cycle) return cycle;
|
|
1338
|
+
}
|
|
1339
|
+
}
|
|
1340
|
+
|
|
1341
|
+
visited.delete(obj);
|
|
1342
|
+
return null;
|
|
1343
|
+
},
|
|
1344
|
+
|
|
1345
|
+
// 增强安全深拷贝，主动移除循环引用字段
|
|
1346
|
+
safeDeepCopy(obj, hash = new WeakMap()) {
|
|
1347
|
+
if (obj === null || typeof obj !== 'object') {
|
|
1348
|
+
return obj;
|
|
1349
|
+
}
|
|
1350
|
+
|
|
1351
|
+
// 检测到循环引用时，保留核心字段（orgUnitId必选，其他字段尽可能保留）
|
|
1352
|
+
if (hash.has(obj)) {
|
|
1353
|
+
const safeObj = {
|
|
1354
|
+
orgUnitId: obj.orgUnitId,
|
|
1355
|
+
orgNodeName: obj.orgNodeName || obj.name || `未命名组织(${obj.orgUnitId || 'unknown'})`,
|
|
1356
|
+
orgUnitName: obj.orgUnitName || obj.orgNodeName || obj.name || `未命名组织(${obj.orgUnitId || 'unknown'})`,
|
|
1357
|
+
parentOrgUnitId: obj.parentOrgUnitId || obj.parentId || null
|
|
1358
|
+
};
|
|
1359
|
+
hash.set(obj, safeObj);
|
|
1360
|
+
return safeObj;
|
|
1361
|
+
}
|
|
1362
|
+
|
|
1363
|
+
let copy;
|
|
1364
|
+
if (obj instanceof Array) {
|
|
1365
|
+
copy = [];
|
|
1366
|
+
hash.set(obj, copy);
|
|
1367
|
+
for (let i = 0; i < obj.length; i++) {
|
|
1368
|
+
copy[i] = this.safeDeepCopy(obj[i], hash);
|
|
1369
|
+
}
|
|
1370
|
+
} else if (obj instanceof Object) {
|
|
1371
|
+
copy = {};
|
|
1372
|
+
hash.set(obj, copy);
|
|
1373
|
+
for (let key in obj) {
|
|
1374
|
+
if (obj.hasOwnProperty(key)) {
|
|
1375
|
+
// 仅过滤vue内部字段，保留业务字段
|
|
1376
|
+
if (['__vue__', '__ob__', '$parent', '$children'].includes(key)) {
|
|
1377
|
+
continue;
|
|
1378
|
+
}
|
|
1379
|
+
// 子节点数组特殊处理
|
|
1380
|
+
if (['orgChildrenList', 'children'].includes(key) && Array.isArray(obj[key])) {
|
|
1381
|
+
copy[key] = obj[key].map(child => this.safeDeepCopy(child, hash));
|
|
1382
|
+
} else {
|
|
1383
|
+
// 保留所有业务字段，不额外过滤
|
|
1384
|
+
copy[key] = this.safeDeepCopy(obj[key], hash);
|
|
1385
|
+
}
|
|
1386
|
+
}
|
|
1387
|
+
}
|
|
1388
|
+
} else {
|
|
1389
|
+
copy = obj;
|
|
1390
|
+
}
|
|
1391
|
+
return copy;
|
|
1392
|
+
},
|
|
1393
|
+
|
|
1394
|
+
/**
|
|
1395
|
+
* 查询单个节点的原生详情（适配后端接口，返回原生字段）
|
|
1396
|
+
* @param {string} orgUnitId - 节点ID（如11510101）
|
|
1397
|
+
* @returns {Promise<Object|null>} 原生节点详情（无数据返回null）
|
|
1398
|
+
*/
|
|
1399
|
+
getOrgNodeDetail(orgUnitId) {
|
|
1400
|
+
return new Promise((resolve) => {
|
|
1401
|
+
ajax.get(`/pub-manage-server/pub/organ/q/queryOrg`, {
|
|
1402
|
+
params: { orgUnitId: orgUnitId }
|
|
1403
|
+
}).then((res) => {
|
|
1404
|
+
if (res.data.code === 1 && res.data.data) {
|
|
1405
|
+
// 仅保留原生树结构必需字段（过滤业务冗余字段）
|
|
1406
|
+
const { orgUnitId, parentOrgUnitId, orgNodeName, orgChildrenList } = res.data.data;
|
|
1407
|
+
resolve({
|
|
1408
|
+
orgUnitId,
|
|
1409
|
+
parentOrgUnitId,
|
|
1410
|
+
orgNodeName,
|
|
1411
|
+
orgChildrenList: orgChildrenList || [] // 兼容接口返回空的情况
|
|
1412
|
+
});
|
|
1413
|
+
} else {
|
|
1414
|
+
resolve(null);
|
|
1415
|
+
}
|
|
1416
|
+
}).catch(() => {
|
|
1417
|
+
this.$Message.error(`查询节点【${orgUnitId}】详情失败`);
|
|
1418
|
+
resolve(null);
|
|
1419
|
+
});
|
|
1420
|
+
});
|
|
1421
|
+
},
|
|
1422
|
+
|
|
1423
|
+
/**
|
|
1424
|
+
* 迭代查找节点（替代递归，避免栈溢出）
|
|
1425
|
+
* @param {Array} treeData - 树形数据
|
|
1426
|
+
* @param {string} targetOrgUnitId - 目标节点ID
|
|
1427
|
+
* @returns {Object|null} 找到的节点
|
|
1428
|
+
*/
|
|
1429
|
+
findNodeInTree(treeData, targetOrgUnitId) {
|
|
1430
|
+
if (!Array.isArray(treeData) || !targetOrgUnitId || typeof targetOrgUnitId !== 'string') {
|
|
1431
|
+
return null;
|
|
1432
|
+
}
|
|
1433
|
+
|
|
1434
|
+
const queue = [...treeData];
|
|
1435
|
+
while (queue.length > 0) {
|
|
1436
|
+
const currentNode = queue.shift();
|
|
1437
|
+
// 兼容子组件可能的字段映射（orgUnitId可能存储在id字段）
|
|
1438
|
+
const nodeId = currentNode.orgUnitId || currentNode.id || '';
|
|
1439
|
+
if (nodeId === targetOrgUnitId) {
|
|
1440
|
+
return currentNode;
|
|
1441
|
+
}
|
|
1442
|
+
// 兼容children和orgChildrenList两种子节点字段
|
|
1443
|
+
const childNodes = currentNode.orgChildrenList || currentNode.children || [];
|
|
1444
|
+
if (childNodes.length > 0) {
|
|
1445
|
+
queue.push(...childNodes);
|
|
1446
|
+
}
|
|
1447
|
+
}
|
|
1448
|
+
return null;
|
|
1449
|
+
},
|
|
1450
|
+
|
|
1451
|
+
/**
|
|
1452
|
+
* 辅助方法：查询单个orgUnitId的节点详情
|
|
1453
|
+
* @param {string} orgUnitId - 组织节点ID
|
|
1454
|
+
* @returns {Promise<Object|null>} 节点详情
|
|
1455
|
+
*/
|
|
1456
|
+
queryOrgNodeDetail(orgUnitId) {
|
|
1457
|
+
return new Promise((resolve) => {
|
|
1458
|
+
// 前置校验：避免无效请求
|
|
1459
|
+
if (!orgUnitId || typeof orgUnitId !== 'string') {
|
|
1460
|
+
resolve(null);
|
|
1461
|
+
return;
|
|
1462
|
+
}
|
|
1463
|
+
|
|
1464
|
+
ajax.get(`/pub-manage-server/pub/organ/q/queryOrg?orgUnitId=${orgUnitId}`)
|
|
1465
|
+
.then((res) => {
|
|
1466
|
+
if (res.data.code === 1 && res.data.data && res.data.data.orgUnitId) {
|
|
1467
|
+
// 深拷贝并清理无效字段
|
|
1468
|
+
const node = this.safeDeepCopy(res.data.data);
|
|
1469
|
+
// 核心修复：确保节点名称有默认值，避免空显示
|
|
1470
|
+
const nodeName = node.orgNodeName || node.orgUnitName || node.name || `未命名组织(${orgUnitId})`;
|
|
1471
|
+
node.orgNodeName = nodeName;
|
|
1472
|
+
node.orgUnitName = nodeName; // 同步更新orgUnitName，确保所有使用场景都有值
|
|
1473
|
+
// 确保关键字段存在
|
|
1474
|
+
node.parentOrgUnitId = node.parentOrgUnitId || null;
|
|
1475
|
+
node.orgChildrenList = node.orgChildrenList || [];
|
|
1476
|
+
resolve(node);
|
|
1477
|
+
} else {
|
|
1478
|
+
// 接口返回空时，返回默认结构避免报错
|
|
1479
|
+
resolve({
|
|
1480
|
+
orgUnitId,
|
|
1481
|
+
orgNodeName: `未命名组织(${orgUnitId})`,
|
|
1482
|
+
orgUnitName: `未命名组织(${orgUnitId})`,
|
|
1483
|
+
parentOrgUnitId: null,
|
|
1484
|
+
orgChildrenList: []
|
|
1485
|
+
});
|
|
1486
|
+
}
|
|
1487
|
+
})
|
|
1488
|
+
.catch(() => {
|
|
1489
|
+
// 请求失败时，返回默认结构避免报错
|
|
1490
|
+
resolve({
|
|
1491
|
+
orgUnitId,
|
|
1492
|
+
orgNodeName: `未命名组织(${orgUnitId})`,
|
|
1493
|
+
orgUnitName: `未命名组织(${orgUnitId})`,
|
|
1494
|
+
parentOrgUnitId: null,
|
|
1495
|
+
orgChildrenList: []
|
|
1496
|
+
});
|
|
1497
|
+
});
|
|
1498
|
+
});
|
|
1499
|
+
},
|
|
1500
|
+
|
|
1501
|
+
|
|
1502
|
+
/**
|
|
1503
|
+
* 手动更新树节点状态
|
|
1504
|
+
* @param {Array} nodeList - 节点列表
|
|
1505
|
+
* @param {Set} expandIds - 需要展开的节点ID集合
|
|
1506
|
+
* @param {Set} checkedIds - 需要选中的节点ID集合
|
|
1507
|
+
*/
|
|
1508
|
+
updateTreeNodesStatus(nodeList, expandIds, checkedIds) {
|
|
1509
|
+
nodeList.forEach(node => {
|
|
1510
|
+
// 更新展开状态
|
|
1511
|
+
if (expandIds.has(node.orgUnitId)) {
|
|
1512
|
+
node.expand = true;
|
|
1513
|
+
}
|
|
1514
|
+
|
|
1515
|
+
// 更新选中状态
|
|
1516
|
+
if (checkedIds.has(node.orgUnitId)) {
|
|
1517
|
+
node.checked = true;
|
|
1518
|
+
}
|
|
1519
|
+
|
|
1520
|
+
// 递归处理子节点
|
|
1521
|
+
const children = node.children || node.orgChildrenList;
|
|
1522
|
+
if (children && children.length > 0) {
|
|
1523
|
+
this.updateTreeNodesStatus(children, expandIds, checkedIds);
|
|
1524
|
+
}
|
|
1525
|
+
});
|
|
1526
|
+
}
|
|
1527
|
+
|
|
306
1528
|
},
|
|
307
1529
|
computed:{
|
|
1530
|
+
computedTabName() {
|
|
1531
|
+
const validTabNames = Array.isArray(this.name) ? this.name : [];
|
|
1532
|
+
return validTabNames.length > 0 ? validTabNames[0] : '';
|
|
1533
|
+
},
|
|
308
1534
|
getCheckedStaff(){
|
|
309
1535
|
return this.staffAllList.filter((item)=>item.checked===true).length
|
|
310
1536
|
},
|
|
@@ -316,11 +1542,26 @@ export default {
|
|
|
316
1542
|
}
|
|
317
1543
|
},
|
|
318
1544
|
watch:{
|
|
1545
|
+
computedTabName(newVal) {
|
|
1546
|
+
if (newVal && this.name.includes(newVal)) {
|
|
1547
|
+
this.activeTabName = newVal;
|
|
1548
|
+
this.$nextTick(() => {
|
|
1549
|
+
// 确保 Tab 组件已渲染后再强制更新
|
|
1550
|
+
if (this.$refs.tabs) {
|
|
1551
|
+
this.$refs.tabs.$forceUpdate();
|
|
1552
|
+
}
|
|
1553
|
+
if (newVal === 'org' || newVal === 'post' || newVal === 'staff') {
|
|
1554
|
+
this.handleTabChange(newVal);
|
|
1555
|
+
}
|
|
1556
|
+
});
|
|
1557
|
+
}
|
|
1558
|
+
},
|
|
319
1559
|
value(val){
|
|
320
1560
|
this.modal = val
|
|
321
1561
|
},
|
|
322
1562
|
data:{
|
|
323
1563
|
handler(val){
|
|
1564
|
+
if(!val) return
|
|
324
1565
|
let map = deepCopy(val)
|
|
325
1566
|
let orgList = map.orgList || []
|
|
326
1567
|
orgList.forEach(item=>{
|
|
@@ -343,6 +1584,263 @@ export default {
|
|
|
343
1584
|
}
|
|
344
1585
|
</script>
|
|
345
1586
|
<style lang="less" scoped>
|
|
1587
|
+
// 新增checkbox样式
|
|
1588
|
+
.staff-checkbox {
|
|
1589
|
+
margin-right: 12px;
|
|
1590
|
+
flex-shrink: 0;
|
|
1591
|
+
|
|
1592
|
+
/deep/ .ivu-checkbox-wrapper {
|
|
1593
|
+
display: flex;
|
|
1594
|
+
align-items: center;
|
|
1595
|
+
cursor: pointer;
|
|
1596
|
+
}
|
|
1597
|
+
|
|
1598
|
+
/deep/ .ivu-checkbox {
|
|
1599
|
+
width: 18px;
|
|
1600
|
+
height: 18px;
|
|
1601
|
+
|
|
1602
|
+
&:checked {
|
|
1603
|
+
/deep/ .ivu-checkbox-inner {
|
|
1604
|
+
background-color: var(--primary-color);
|
|
1605
|
+
border-color: var(--primary-color);
|
|
1606
|
+
}
|
|
1607
|
+
}
|
|
1608
|
+
}
|
|
1609
|
+
}
|
|
1610
|
+
.staff-left-right-layout {
|
|
1611
|
+
display: flex;
|
|
1612
|
+
height: 600px;
|
|
1613
|
+
gap: 15px;
|
|
1614
|
+
padding: 0 5px;
|
|
1615
|
+
width: 100%;
|
|
1616
|
+
box-sizing: border-box;
|
|
1617
|
+
|
|
1618
|
+
.staff-left-panel {
|
|
1619
|
+
min-width: 300px;
|
|
1620
|
+
max-width: 350px;
|
|
1621
|
+
width: 320px;
|
|
1622
|
+
display: flex;
|
|
1623
|
+
flex-direction: column;
|
|
1624
|
+
box-sizing: border-box;
|
|
1625
|
+
flex-shrink: 0;
|
|
1626
|
+
|
|
1627
|
+
.panel-title {
|
|
1628
|
+
font-weight: 600;
|
|
1629
|
+
font-size: 15px;
|
|
1630
|
+
color: #1f2937;
|
|
1631
|
+
margin-bottom: 10px;
|
|
1632
|
+
height: 28px;
|
|
1633
|
+
display: flex;
|
|
1634
|
+
align-items: center;
|
|
1635
|
+
position: relative;
|
|
1636
|
+
padding-left: 18px; // 内边距同步加宽2px，保持视觉平衡
|
|
1637
|
+
// 调整竖线宽度为6px，更醒目且仍符合整体简约风格
|
|
1638
|
+
&::before {
|
|
1639
|
+
content: '';
|
|
1640
|
+
position: absolute;
|
|
1641
|
+
left: 0;
|
|
1642
|
+
top: 50%;
|
|
1643
|
+
transform: translateY(-50%);
|
|
1644
|
+
width: 6px; // 从3px调整为6px，加宽竖线
|
|
1645
|
+
height: 18px; // 高度同步微调至18px，比例更协调
|
|
1646
|
+
background-color: var(--primary-color);
|
|
1647
|
+
border-radius: 3px; // 圆角保持3px，视觉更柔和
|
|
1648
|
+
}
|
|
1649
|
+
}
|
|
1650
|
+
|
|
1651
|
+
.staff-org-tree {
|
|
1652
|
+
height: calc(100% - 38px) !important; // 对应title高度+margin-bottom调整
|
|
1653
|
+
overflow: auto;
|
|
1654
|
+
border: 1px solid #EAECF0;
|
|
1655
|
+
border-radius: 4px;
|
|
1656
|
+
padding: 8px;
|
|
1657
|
+
box-sizing: border-box;
|
|
1658
|
+
// 保持原有树节点样式
|
|
1659
|
+
/deep/ .ivu-tree-node-content {
|
|
1660
|
+
white-space: normal !important;
|
|
1661
|
+
line-height: 1.4;
|
|
1662
|
+
padding: 4px 0;
|
|
1663
|
+
}
|
|
1664
|
+
/deep/ .ivu-tree-node {
|
|
1665
|
+
padding-left: 4px !important;
|
|
1666
|
+
}
|
|
1667
|
+
/deep/ .ivu-tree-child-tree {
|
|
1668
|
+
padding-left: 16px !important;
|
|
1669
|
+
}
|
|
1670
|
+
}
|
|
1671
|
+
}
|
|
1672
|
+
|
|
1673
|
+
.staff-right-panel {
|
|
1674
|
+
flex: 1 !important;
|
|
1675
|
+
min-width: 350px;
|
|
1676
|
+
width: calc(100% - 335px) !important;
|
|
1677
|
+
display: flex;
|
|
1678
|
+
flex-direction: column;
|
|
1679
|
+
box-sizing: border-box;
|
|
1680
|
+
gap: 8px;
|
|
1681
|
+
padding: 0 5px;
|
|
1682
|
+
flex-shrink: 0;
|
|
1683
|
+
|
|
1684
|
+
// 其他右侧样式保持不变...
|
|
1685
|
+
}
|
|
1686
|
+
}
|
|
1687
|
+
|
|
1688
|
+
// 其他原有样式保持不变
|
|
1689
|
+
/deep/ .ivu-tree {
|
|
1690
|
+
width: 100% !important;
|
|
1691
|
+
box-sizing: border-box;
|
|
1692
|
+
}
|
|
1693
|
+
|
|
1694
|
+
/deep/ .ivu-tree-node-content {
|
|
1695
|
+
width: 100% !important;
|
|
1696
|
+
box-sizing: border-box;
|
|
1697
|
+
}
|
|
1698
|
+
|
|
1699
|
+
.gust-item {
|
|
1700
|
+
display: flex;
|
|
1701
|
+
align-items: center;
|
|
1702
|
+
width: 100% !important;
|
|
1703
|
+
padding: 12px 12px;
|
|
1704
|
+
margin-top: 8px;
|
|
1705
|
+
cursor: pointer;
|
|
1706
|
+
box-sizing: border-box;
|
|
1707
|
+
border: none !important; // 强制移除默认边框
|
|
1708
|
+
}
|
|
1709
|
+
|
|
1710
|
+
// 恢复滚动条样式（确保滚动可见）
|
|
1711
|
+
.staff-content::-webkit-scrollbar {
|
|
1712
|
+
width: 8px !important;
|
|
1713
|
+
height: 8px;
|
|
1714
|
+
display: block !important;
|
|
1715
|
+
}
|
|
1716
|
+
|
|
1717
|
+
.staff-content::-webkit-scrollbar-thumb {
|
|
1718
|
+
background-color: #ccc !important;
|
|
1719
|
+
border-radius: 4px !important;
|
|
1720
|
+
}
|
|
1721
|
+
|
|
1722
|
+
.staff-content::-webkit-scrollbar-track {
|
|
1723
|
+
background-color: #f9f9f9 !important;
|
|
1724
|
+
}
|
|
1725
|
+
|
|
1726
|
+
// 其他原有样式保持不变
|
|
1727
|
+
.tab.post .left {
|
|
1728
|
+
width: 200px;
|
|
1729
|
+
height: 450px !important;
|
|
1730
|
+
overflow: hidden !important;
|
|
1731
|
+
padding-right: 10px;
|
|
1732
|
+
box-sizing: border-box;
|
|
1733
|
+
}
|
|
1734
|
+
|
|
1735
|
+
.scroll-container {
|
|
1736
|
+
height: 100% !important;
|
|
1737
|
+
overflow-y: auto !important;
|
|
1738
|
+
overflow-x: hidden !important;
|
|
1739
|
+
padding: 8px 0;
|
|
1740
|
+
margin: 0;
|
|
1741
|
+
box-sizing: border-box;
|
|
1742
|
+
}
|
|
1743
|
+
|
|
1744
|
+
.scroll-container::-webkit-scrollbar {
|
|
1745
|
+
width: 8px !important;
|
|
1746
|
+
height: 8px;
|
|
1747
|
+
display: block !important;
|
|
1748
|
+
}
|
|
1749
|
+
|
|
1750
|
+
.scroll-container::-webkit-scrollbar-thumb {
|
|
1751
|
+
background-color: #ccc !important;
|
|
1752
|
+
border-radius: 4px !important;
|
|
1753
|
+
transition: background-color 0.2s;
|
|
1754
|
+
}
|
|
1755
|
+
|
|
1756
|
+
.scroll-container::-webkit-scrollbar-thumb:hover {
|
|
1757
|
+
background-color: #999 !important;
|
|
1758
|
+
}
|
|
1759
|
+
|
|
1760
|
+
.scroll-container::-webkit-scrollbar-track {
|
|
1761
|
+
background-color: #f9f9f9 !important;
|
|
1762
|
+
border-radius: 4px !important;
|
|
1763
|
+
}
|
|
1764
|
+
|
|
1765
|
+
.position-item {
|
|
1766
|
+
border: 1px solid #ddd;
|
|
1767
|
+
margin: 5px 0;
|
|
1768
|
+
padding: 8px 10px;
|
|
1769
|
+
border-radius: 2px;
|
|
1770
|
+
cursor: pointer;
|
|
1771
|
+
transition: background-color 0.2s;
|
|
1772
|
+
white-space: normal !important;
|
|
1773
|
+
overflow: visible !important;
|
|
1774
|
+
text-overflow: clip !important;
|
|
1775
|
+
line-height: 1.4;
|
|
1776
|
+
min-height: 40px;
|
|
1777
|
+
word-wrap: break-word;
|
|
1778
|
+
}
|
|
1779
|
+
|
|
1780
|
+
.position-item.active {
|
|
1781
|
+
border-color: #1890ff;
|
|
1782
|
+
background-color: #e6f7ff;
|
|
1783
|
+
}
|
|
1784
|
+
|
|
1785
|
+
.position-item:hover:not(.active) {
|
|
1786
|
+
background-color: #f5f5f5;
|
|
1787
|
+
}
|
|
1788
|
+
|
|
1789
|
+
.custom-select-wrapper {
|
|
1790
|
+
position: relative;
|
|
1791
|
+
|
|
1792
|
+
/deep/ .ivu-select-clear {
|
|
1793
|
+
right: 32px;
|
|
1794
|
+
color: #999;
|
|
1795
|
+
font-size: 16px;
|
|
1796
|
+
opacity: 1 !important;
|
|
1797
|
+
transition: all 0.2s ease;
|
|
1798
|
+
|
|
1799
|
+
&:hover {
|
|
1800
|
+
color: #ff4d4f;
|
|
1801
|
+
transform: scale(1.1);
|
|
1802
|
+
}
|
|
1803
|
+
}
|
|
1804
|
+
|
|
1805
|
+
/deep/ .ivu-select-arrow {
|
|
1806
|
+
right: 12px;
|
|
1807
|
+
}
|
|
1808
|
+
|
|
1809
|
+
/deep/ .ivu-select-input {
|
|
1810
|
+
padding-right: 45px !important;
|
|
1811
|
+
}
|
|
1812
|
+
|
|
1813
|
+
/deep/ .active-option {
|
|
1814
|
+
background-color: #f2f8ff;
|
|
1815
|
+
color: var(--primary-color);
|
|
1816
|
+
}
|
|
1817
|
+
|
|
1818
|
+
/deep/ .ivu-select-option-disabled {
|
|
1819
|
+
color: #ccc !important;
|
|
1820
|
+
background: #f5f5f5 !important;
|
|
1821
|
+
}
|
|
1822
|
+
}
|
|
1823
|
+
|
|
1824
|
+
.tag-select-container {
|
|
1825
|
+
margin-left: 10px;
|
|
1826
|
+
|
|
1827
|
+
/deep/ .ivu-select-dropdown {
|
|
1828
|
+
max-height: 200px;
|
|
1829
|
+
overflow-y: auto;
|
|
1830
|
+
}
|
|
1831
|
+
|
|
1832
|
+
/deep/ .active-option {
|
|
1833
|
+
background-color: #f2f8ff;
|
|
1834
|
+
color: var(--primary-color);
|
|
1835
|
+
}
|
|
1836
|
+
|
|
1837
|
+
/deep/ .ivu-select-selected-value {
|
|
1838
|
+
max-width: 150px;
|
|
1839
|
+
overflow: hidden;
|
|
1840
|
+
text-overflow: ellipsis;
|
|
1841
|
+
}
|
|
1842
|
+
}
|
|
1843
|
+
|
|
346
1844
|
.modal-tree{
|
|
347
1845
|
.header-text{
|
|
348
1846
|
font-weight: bold;
|
|
@@ -352,7 +1850,7 @@ export default {
|
|
|
352
1850
|
.icon-tip{
|
|
353
1851
|
width: 16px;
|
|
354
1852
|
height: 16px;
|
|
355
|
-
background:
|
|
1853
|
+
background: var(--primary-color);
|
|
356
1854
|
border-radius: 50%;
|
|
357
1855
|
color: #fff;
|
|
358
1856
|
line-height: 16px;
|
|
@@ -419,12 +1917,26 @@ export default {
|
|
|
419
1917
|
border: 1px solid #EAECF0;
|
|
420
1918
|
margin-left:10px;
|
|
421
1919
|
font-weight: bold;
|
|
1920
|
+
cursor: pointer;
|
|
422
1921
|
&.active{
|
|
423
|
-
background:
|
|
1922
|
+
background: var(--primary-color);
|
|
424
1923
|
border-radius: 4px;
|
|
425
1924
|
color: #fff;
|
|
426
1925
|
}
|
|
427
1926
|
}
|
|
1927
|
+
.pop-content{
|
|
1928
|
+
display: flex;
|
|
1929
|
+
flex-wrap: wrap;
|
|
1930
|
+
width:500px;
|
|
1931
|
+
.tag{
|
|
1932
|
+
margin-top: 10px;
|
|
1933
|
+
&.active{
|
|
1934
|
+
background: var(--primary-color);
|
|
1935
|
+
border-radius: 4px;
|
|
1936
|
+
color: #fff;
|
|
1937
|
+
}
|
|
1938
|
+
}
|
|
1939
|
+
}
|
|
428
1940
|
.post{
|
|
429
1941
|
display: flex;
|
|
430
1942
|
height: 100%;
|
|
@@ -483,14 +1995,19 @@ export default {
|
|
|
483
1995
|
}
|
|
484
1996
|
.checked-icon{
|
|
485
1997
|
margin-left:auto;
|
|
486
|
-
color
|
|
1998
|
+
color:var(--primary-color);
|
|
487
1999
|
font-size:18px;
|
|
488
2000
|
}
|
|
489
2001
|
}
|
|
490
|
-
.staff-active{
|
|
491
|
-
background
|
|
492
|
-
|
|
493
|
-
|
|
2002
|
+
.staff-active {
|
|
2003
|
+
background: transparent !important; // 彻底移除背景色
|
|
2004
|
+
border: none !important; // 彻底移除边框高亮
|
|
2005
|
+
border-radius: 0 !important; // 移除圆角
|
|
2006
|
+
|
|
2007
|
+
> .right-panel > p:first-child {
|
|
2008
|
+
color: inherit !important; // 可选：也移除文字颜色变化，仅保留Checkbox选中
|
|
2009
|
+
// 如果需要保留文字变色，删除上面这行，保留下面注释的行
|
|
2010
|
+
// color: var(--primary-color);
|
|
494
2011
|
}
|
|
495
2012
|
}
|
|
496
2013
|
}
|
|
@@ -559,7 +2076,5 @@ export default {
|
|
|
559
2076
|
justify-content: space-between;
|
|
560
2077
|
}
|
|
561
2078
|
}
|
|
562
|
-
/deep/.ivu-modal-body-no-scrollbar-width :not([class^="ivu-table"])::-webkit-scrollbar{
|
|
563
|
-
}
|
|
564
2079
|
}
|
|
565
2080
|
</style>
|