dangsn
2024-06-07 7664ba49025a6c549885fc6019e4d3c1886f45a6
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
package com.vci.frameworkcore.compatibility.impl;
 
import com.vci.client.common.providers.ServiceProvider;
import com.vci.common.util.ThreeDES;
import com.vci.corba.common.PLException;
import com.vci.frameworkcore.compatibility.SmUserQueryServiceI;
import com.vci.frameworkcore.pagemodel.SmPasswordStrategyVO;
import com.vci.frameworkcore.pagemodel.SmUserVO;
import com.vci.starter.web.enumpck.BooleanEnum;
import com.vci.starter.web.exception.VciBaseException;
import com.vci.starter.web.pagemodel.DataGrid;
import com.vci.starter.web.pagemodel.PageHelper;
import com.vci.starter.web.pagemodel.Tree;
import com.vci.starter.web.pagemodel.TreeQueryObject;
import com.vci.starter.web.util.BeanUtil;
import com.vci.starter.web.util.VciBaseUtil;
import com.vci.starter.web.wrapper.VciQueryWrapperForDO;
import com.vci.web.model.SmPasswordStrategyDO;
import com.vci.web.model.SmUserDO;
import com.vci.web.service.WebBoServiceI;
import com.vci.web.util.PlatformClientUtil;
import com.vci.web.util.WebUtil;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
 
import java.util.*;
import java.util.stream.Collectors;
 
import static com.vci.frameworkcore.constant.FrameWorkBusLangCodeConstant.DATA_OID_NOT_EXIST;
import static com.vci.web.util.WebUtil.arryAndSqlToClientBusinessObject;
 
/**
 * 用户的查询相关的服务,可以兼容老平台和老的pdm
 * 其中包含登录相关的接口和参照,根据主键查询等接口
 * 所有的数据全部转换为新平台的对象
 * @author xiejun
 * @date 2020/3/10
 */
@Service
public class SmUserQueryServiceImpl implements SmUserQueryServiceI {
 
    /**
     * 平台调用客户端
     */
    @Autowired
    private PlatformClientUtil platformClientUtil;
 
    /**
     * 业务数据服务
     */
    @Autowired
    private WebBoServiceI boService;
 
    /**
     * 使用角色的属性查询用户时
     */
    private final static String QUERY_BY_ROLE_KEY_PREFIX = "pkrole.";
 
    /**
     * 角色的表格昵称
     */
    public static final String NICK_BY_ROLE = "pkrole";
 
    /**
     * 使用部门查询的时候的查询字段
     */
    public static final String QUERY_FIELD_DEPARTMENT = "up.pldeptuid";
 
    /**
     * 使用职务查询的时候的查询字段
     */
    public static final String QUERY_FIELD_DUTY = "pkDuty";
 
    /**
     * 使用角色查询的时候的查询字段
     */
    public static final String QUERY_FIELD_ROLE = "roleUser.plroleuid";
 
    /**
     * 自引用
     */
    @Autowired(required = false)
    @Lazy
    private SmUserQueryServiceI self;
 
    /**
     *  根据用户名获取用户的对象,不区分大小写
     * @param userId 用户名
     * @return 用户的显示对象,如果用户不存在则返回null,不会抛出异常
     * @throws VciBaseException 参数为空或者数据库存在问题的时候会抛出异常
     */
    @Override
    public SmUserVO getUserByUserId(String userId) throws VciBaseException {
        WebUtil.alertNotNull(userId,"用户名");
        return getUserByField("plusername",userId);
    }
 
    /**
     * 使用字段获取用户的信息
     * @param queryField 字段
     * @param queryValue 查询值
     * @return 用户的信息
     * @throws VciBaseException 查询出错的时候会抛出异常
     */
    private SmUserVO getUserByField(String queryField,String queryValue) throws VciBaseException{
        VciQueryWrapperForDO queryWrapper = new VciQueryWrapperForDO(null,SmUserDO.class,null,true);
        queryWrapper.eq(queryWrapper.getTableNick() + "." +queryField,queryValue);
        queryWrapper.setDistinct(true);
        queryWrapper.wrapperSql();
        addRoleQuerySql(queryWrapper);
        String sql =  queryWrapper.getSelectFieldSql();
        String fromSql = " from pluser " + queryWrapper.getTableNick()
                + " left join pluserdept up on " + queryWrapper.getTableNick() + ".pluid = up.pluseruid left join pldept pkDepartment on  up.pldeptuid = pkDepartment.pluid " +
                " left join PLUSERPASSWORDSTRATEGY pkUserPassword on  " +queryWrapper.getTableNick() + ".pluid = pkUserPassword.pluseruid " +
                queryWrapper.getLinkTableSql() + (StringUtils.isNotBlank(queryWrapper.getWhereSql())?(" where " + queryWrapper.getWhereSql()):"");
        try{
            String[][] sqlQueryResult = ServiceProvider.getBOFService().getSqlQueryResult(sql + fromSql, null);
            if(sqlQueryResult.length>0){
                com.vci.client.bof.ClientBusinessObject cbo = arryAndSqlToClientBusinessObject(queryWrapper.getSelectFieldSql(),sqlQueryResult[0]);
                return cbo2VO(cbo);
            }
        }catch (Exception e){
            throw new VciBaseException("数据解析错误:" + e );
        }
        return null;
    }
 
    /**
     * 使用属性集合查询用户
     * @param queryField 查询的字段
     * @param queryValues 查询的值集合
     * @return 用户的显示对象
     * @throws VciBaseException 查询出错的时候会抛出异常
     */
    private List<SmUserVO> listUserByField(String queryField,Collection<String> queryValues) throws VciBaseException{
        List<SmUserVO> userVOList = new ArrayList<>();
        WebUtil.switchCollectionForOracleIn(queryValues).forEach(values->{
            VciQueryWrapperForDO queryWrapper = new VciQueryWrapperForDO(null,SmUserDO.class,null,true);
            queryWrapper.in(queryWrapper.getTableNick() + "." + queryField,WebUtil.toInSql(values.toArray(new String[0])));
            queryWrapper.setDistinct(true);
            queryWrapper.wrapperSql();
            String sql = queryWrapper.getSelectFieldSql();
            String fromSql = " from pluser " + queryWrapper.getTableNick()
                    + " left join pluserdept up on " + queryWrapper.getTableNick() + ".pluid = up.pluseruid left join pldept pkDepartment on  up.pldeptuid = pkDepartment.pluid " +
                    " left join PLUSERPASSWORDSTRATEGY pkUserPassword on  " +queryWrapper.getTableNick() + ".pluid = pkUserPassword.pluseruid " +
                    queryWrapper.getLinkTableSql() + (StringUtils.isNotBlank(queryWrapper.getWhereSql())?(" where " + queryWrapper.getWhereSql()):"");
            List<com.vci.client.bof.ClientBusinessObject> dataList = boService.queryBySql(sql + fromSql, null);
            if(!CollectionUtils.isEmpty(dataList)){
                dataList.stream().forEach(cbo->{
                    userVOList.add(cbo2VO(cbo));
                });
            }
        });
        return userVOList;
    }
 
    /**
     * 批量获取用户的信息(根据用户名)
     * @param userIdCollections 用户名的集合,可以超过1000个
     * @return 用户的显示对象,如果用户不存在则返回空的列表,不会抛出异常
     * @throws VciBaseException 参数为空或者数据库存在问题的时候会抛出异常
     */
    @Override
    public List<SmUserVO> listUserByUserIds(Collection<String> userIdCollections)throws VciBaseException {
        WebUtil.alertNotNull(userIdCollections,"用户名集合");
        return listUserByField("plusername",userIdCollections);
    }
    /**
     * 根据用户主键获取用户的信息
     * @param userOid 用户主键
     * @return 用户的显示对象,如果用户不存在则返回null,不会抛出异常
     * @throws VciBaseException 参数为空或者数据库存在问题的时候会抛出异常
     */
    @Override
    public SmUserVO getUserByUserOid(String userOid) throws VciBaseException {
        WebUtil.alertNotNull(userOid,"用户主键");
        return getUserByField("pluid",userOid);
    }
     /**
     * 批量获取用户的信息 (根据用户主键)
     * @param userOidCollections 用户主键的集合,可以超过1000个
     * @return 用户的显示对象,如果用户不存在则返回空的列表,不会抛出异常
     * @throws VciBaseException 参数为空或者数据库存在问题的时候会抛出异常
     */
    @Override
    public List<SmUserVO> listUserByUserOids(
            Collection<String> userOidCollections) throws VciBaseException {
        WebUtil.alertNotNull(userOidCollections,"用户主键集合");
        return listUserByField("pluid",userOidCollections);
    }
 
    /**
     * 用户的数据对象转换为显示对象
     * @param userDOS 用户
     * @return 显示对象
     */
    private List<SmUserVO> smUserDO2VOs(List<SmUserDO> userDOS){
        List<SmUserVO> userVOList = new ArrayList<>();
        Optional.ofNullable(userDOS).orElseGet(()->new ArrayList<>()).stream().forEach(userDO->{
            SmUserVO userVO = new SmUserVO();
            BeanUtil.convert(userDO,userVO);
            userVOList.add(userVO);
        });
        return userVOList;
    }
 
    /**
     * 使用属性来的查询用户的信息
     * @param queryField 查询的属性
     * @param queryValue 查询的值
     * @param queryMap 查询的条件,如果是角色的属性,需要使用pkrole.xxx
     * @param notIn 是否为不包含
     * @return 用户的对象
     */
    private List<SmUserVO> listUserByQueryField(String queryField,String queryValue,Map<String,String> queryMap,boolean notIn){
        if(StringUtils.isBlank(queryValue)){
            return new ArrayList<>();
        }
        VciQueryWrapperForDO queryWrapper = getQueryWrapper(queryField, queryValue, queryMap, null, notIn);
        List<SmUserVO> userVOList = new ArrayList<>();
        queryWrapper.wrapperSql();
        String sql = queryWrapper.getSelectFieldSql();
        String roleSql = " left join pluserrole roleuser on " + queryWrapper.getTableNick() + ".pluid = roleuser.pluseruid ";
        String fromSql = " from pluser " + queryWrapper.getTableNick()
                + " left join pluserdept up on " + queryWrapper.getTableNick() + ".pluid = up.pluseruid left join pldept pkDepartment on  up.pldeptuid = pkDepartment.pluid " +
                " left join PLUSERPASSWORDSTRATEGY pkUserPassword on  " +queryWrapper.getTableNick() + ".pluid = pkUserPassword.pluseruid " + (QUERY_FIELD_ROLE.equalsIgnoreCase(queryField)?roleSql:"") +
                queryWrapper.getLinkTableSql() + (StringUtils.isNotBlank(queryWrapper.getWhereSql())?(" where " + queryWrapper.getWhereSql()):"");
        List<com.vci.client.bof.ClientBusinessObject> dataList = boService.queryBySql(sql + fromSql, null);
        if(!CollectionUtils.isEmpty(dataList)){
            dataList.stream().forEach(cbo->{
                userVOList.add(cbo2VO(cbo));
            });
        }
        return userVOList;
    }
 
    /**
     * 业务数据转换为显示对象
     * @param cbo 业务数据
     * @return 显示对象
     */
    private SmUserVO cbo2VO(com.vci.client.bof.ClientBusinessObject cbo){
        SmUserDO userDO = new SmUserDO();
        SmUserVO userVO = new SmUserVO();
        WebUtil.copyValueToObjectFromCbos(cbo,userDO);
        if("0".equals(userDO.getLockFlag())){
            userDO.setLockFlag(BooleanEnum.FASLE.getValue());
        }else{
            userDO.setLockFlag(BooleanEnum.TRUE.getValue());
        }
        BeanUtil.convert(userDO,userVO);
        return userVO;
    }
 
    /**
     * 使用某个属性来查询用户的信息
     * @param queryField 查询的属性名称
     * @param queryValue 查询的值
     * @param queryMap 其他查询条件,如果是角色的属性,需要使用pkrole.xxx
     * @param pageHelper 分页对象
     * @param notIn 是否为不包含
     * @return 用户的显示对象的列表
     */
    private DataGrid<SmUserVO> gridUserByQueryField(String queryField,String queryValue, Map<String, String> queryMap, PageHelper pageHelper,boolean notIn){
        if(StringUtils.isBlank(queryValue)){
            return new DataGrid<>();
        }
        PageHelper newPageHelper = new PageHelper(-1);
        newPageHelper.setSort(pageHelper.getSort());
        newPageHelper.setOrder(pageHelper.getOrder());
        VciQueryWrapperForDO queryWrapper = getQueryWrapper(queryField, queryValue, queryMap, newPageHelper, notIn);
 
        List<SmUserVO> userVOList = new ArrayList<>();
        queryWrapper.wrapperSql();
        String sql = queryWrapper.getSelectFieldSql();
        String fromSql = " from pluser " + queryWrapper.getTableNick()
                + " left join pluserdept up on " + queryWrapper.getTableNick() + ".pluid = up.pluseruid left join pldept pkDepartment on  up.pldeptuid = pkDepartment.pluid " +
                " left join PLUSERPASSWORDSTRATEGY pkUserPassword on  " +queryWrapper.getTableNick() + ".pluid = pkUserPassword.pluseruid " +
                " left join PLUSERROLE roleuser on roleuser.PLUSERUID = "+queryWrapper.getTableNick() +".PLUID"+
                queryWrapper.getLinkTableSql() + (StringUtils.isNotBlank(queryWrapper.getWhereSql())?(" where " + queryWrapper.getWhereSql()):"");
        boolean isPage = pageHelper != null && pageHelper.getLimit() > 0;
        String pageSubfix = " ) A where rownum < " + (pageHelper.getLimit() * pageHelper.getPage() + 1) + ") where RN >= " + (pageHelper.getLimit() * (pageHelper.getPage() - 1) + 1);
        List<String> pageSelectList = new ArrayList<>();
        String temp = queryWrapper.getSelectFieldSql();
        if(StringUtils.isNotBlank(temp)){
            String[] split = temp.split(",");
            if(split!=null&&split.length>0){
                for (int i = 0; i < split.length; i++) {
                    String s = split[i];
                    if(s.contains(" as ")){
                        pageSelectList.add(s.split(" as ")[1]);
                    }
                }
            }
        }
        List<com.vci.client.bof.ClientBusinessObject> dataList = boService.queryBySql((isPage?("select " + pageSelectList.stream().collect(Collectors.joining(","))+ " from (select A.*,rownum RN from ( "):"") + sql + fromSql + (isPage?pageSubfix:""), null);
        if(!CollectionUtils.isEmpty(dataList)){
            dataList.stream().forEach(cbo->{
                userVOList.add(cbo2VO(cbo));
            });
        }
        DataGrid<SmUserVO> dataGrid = new DataGrid<>();
        if(!CollectionUtils.isEmpty(dataList)){
            dataGrid.setData(userVOList);
            queryWrapper.clearPage();
            dataGrid.setTotal(boService.queryCountBySql("select count(*) as count " + fromSql,null));
        }
        return dataGrid;
    }
    /**
     * 获取用户的列表,默认会以用户名升序排列,用户的编辑页面列表不要使用这个接口
     * @param queryMap 查询条件
     * @param pageHelper 分页和排序的信息,在兼容老平台的时候会自动兼容,如果属性不存在会自动忽略
     * @return 用户的显示对象列表
     * @throws VciBaseException 参数为空的时候会抛出异常
     */
    @Override
    public DataGrid<SmUserVO> gridUsers(Map<String, String> queryMap,
                                        PageHelper pageHelper) throws VciBaseException {
        return gridUserByQueryField(null,null,queryMap,pageHelper,false);
    }
 
    /**
     * 添加角色的查询的sql, 自动判断是否需要查询角色
     * @param queryMap 查询条件
     * @param queryWrapper 查询封装器
     */
    private void addRoleQuerySql(Map<String,String> queryMap,VciQueryWrapperForDO queryWrapper){
        if((queryMap !=null&& (queryMap.keySet().stream().anyMatch(s->s.toLowerCase().startsWith(QUERY_BY_ROLE_KEY_PREFIX)) || queryMap.containsKey(QUERY_FIELD_ROLE)))
                || (queryWrapper.getConditionMap() !=null && queryWrapper.getConditionMap().containsKey(QUERY_FIELD_ROLE))){
            addRoleQuerySql(queryWrapper);
        }
    }
 
    /**
     * 添加角色的查询的sql
     * @param queryWrapper 查询封装器
     */
    private void addRoleQuerySql(VciQueryWrapperForDO queryWrapper){
        String nick = queryWrapper.getTableNick();
        queryWrapper.addLinkTableSql("  left join pluserrole roleUser on " + nick + ".pluid = roleUser.pluseruid left join plrole " + NICK_BY_ROLE + " on roleUser.plroleuid = " + NICK_BY_ROLE + ".pluid ");
    }
 
    /**
     * 根据用户名获取用户的姓名
     * @param userId 用户名
     * @return 用户姓名,如果不存在会返回Null
     */
    @Override
    public String getUserNameByUserId(String userId) {
        SmUserVO userVO = self.getUserByUserId(userId);
        return userVO == null?"":userVO.getName();
    }
     /**
     * 根据用户主键获取用户的姓名
     * @param userOid 用户主键
     * @return 用户姓名,如果不存在会返回null
     */
    @Override
    public String getUserNameByUserOid(String userOid) {
        SmUserVO userVO = self.getUserByUserOid(userOid);
        return userVO.getName();
    }
 
 
 
     /**
     * 查询某个部门下的用户对象
     * @param deptOid 部门的主键
     * @param queryMap 查询条件,如果是部门的某个属性作为查询条件,则可以使用pkDepartment.xxx这样的方式
     * @return 用户的显示对象列表
     * @throws VciBaseException 参数为空或者查询出错的时候会抛出异常
     */
    @Override
    public List<SmUserVO> listUserByDeptOid(String deptOid,
            Map<String, String> queryMap) throws VciBaseException {
        if(StringUtils.isBlank(deptOid)){
            return new ArrayList<>();
        }
        return listUserByQueryField(QUERY_FIELD_DEPARTMENT,deptOid,queryMap,false);
    }
 
    /**
     * 获取
     * @param queryField 查询属性
     * @param queryValue 查询的值
     * @param queryMap  查询条件,如果是角色的属性,需要使用pkrole.xxx
     * @param pageHelper 分页对象
     * @param notIn 是否为不包含
     * @return 查询封装器
     */
    private VciQueryWrapperForDO getQueryWrapper(String queryField,String queryValue,Map<String,String> queryMap,PageHelper pageHelper,boolean notIn){
        if(pageHelper == null){
            pageHelper = new PageHelper(-1);
        }
        pageHelper.addDefaultAsc("plusername");
        VciQueryWrapperForDO queryWrapperForDO = new VciQueryWrapperForDO(queryMap,SmUserDO.class,pageHelper);
        if(StringUtils.isNotBlank(queryField)) {
            if (queryValue.contains(",")) {
                if (notIn) {
                    queryWrapperForDO.notIn(queryField, VciBaseUtil.toInSql(VciBaseUtil.str2List(queryValue).toArray(new String[0])));
                } else {
                    queryWrapperForDO.in(queryField, VciBaseUtil.toInSql(VciBaseUtil.str2List(queryValue).toArray(new String[0])));
                }
            } else {
                if (notIn) {
                    queryWrapperForDO.neq(queryField, queryValue);
                } else {
                    queryWrapperForDO.eq(queryField, queryValue);
                }
            }
        }
        addRoleQuerySql(queryMap,queryWrapperForDO);
        queryWrapperForDO.eq("plstatus", "0");
        queryWrapperForDO.eq("plusertype", "2");
        queryWrapperForDO.setDistinct(true);
        return queryWrapperForDO;
    }
    /**
     * 查询某个部门下的用户对象列表
     * @param deptOid 部门的主键
     * @param queryMap 查询条件,如果是部门的某个属性作为查询条件,则可以使用pkDepartment.xxx这样的方式
     * @param pageHelper 分页和排序信息,默认使用用户名升序排列
     * @return 用户的显示对象列表,默认使用用户名升序排列
     * @throws VciBaseException 参数为空或者查询出错的时候会抛出异常
     */
    @Override
    public DataGrid<SmUserVO> gridUserByDeptOid(String deptOid,
            Map<String, String> queryMap, PageHelper pageHelper)
            throws VciBaseException {
        return gridUserByQueryField(QUERY_FIELD_DEPARTMENT,deptOid,queryMap,pageHelper,false);
    }
     /**
     * 批量根据部门的主键获取用户
     * @param deptOidCollection 部门的主键集合
     * @return 部门主键和对应的用户显示对象列表的映射,key部门的主键,value是这个部门下的用户
     * @throws VciBaseException 参数为空或者查询出错的时候会抛出异常
     */
    @Override
    public Map<String, List<SmUserVO>> batchListUserByDeptOids(
            Collection<String> deptOidCollection) throws VciBaseException {
        if(CollectionUtils.isEmpty(deptOidCollection)){
            return new HashMap<>();
        }
        List<SmUserVO> userVOList = listUserByQueryField(QUERY_FIELD_DEPARTMENT,deptOidCollection.stream().collect(Collectors.joining(",")),null,false );
        if(!CollectionUtils.isEmpty(userVOList)){
            return userVOList.stream().filter(s->StringUtils.isNotBlank(s.getPkDepartment())).collect(Collectors.groupingBy(SmUserVO::getPkDepartment));
        }
        return new HashMap<>();
    }
    /**
     * 查询不在某个部门下的用户对象列表
     * @param deptOid 部门的主键
     * @param queryMap 查询条件,如果是部门的某个属性作为查询条件,则可以使用pkDepartment.xxx这样的方式
     * @return 用户的显示对象列表,默认使用用户名升序排列
     * @throws VciBaseException 参数为空或者查询出错的时候会抛出异常
     */
    @Override
    public List<SmUserVO> listUserUnInDeptOid(String deptOid,
            Map<String, String> queryMap) throws VciBaseException {
        if(StringUtils.isBlank(deptOid)){
            return new ArrayList<>();
        }
        return listUserByQueryField(QUERY_FIELD_DEPARTMENT,deptOid,queryMap,true);
    }
    /**
     * 查询不在某个部门下的用户对象列表
     * @param deptOid 部门的主键
     * @param queryMap 查询条件,如果是部门的某个属性作为查询条件,则可以使用pkDepartment.xxx这样的方式
     * @param pageHelper 分页和排序信息,默认使用用户名升序排列
     * @return 用户的显示对象列表,默认使用用户名升序排列
     * @throws VciBaseException 参数为空或者查询出错的时候会抛出异常
     */
    @Override
    public DataGrid<SmUserVO> gridUserUnInDeptOid(String deptOid,
            Map<String, String> queryMap, PageHelper pageHelper)
            throws VciBaseException {
        return gridUserByQueryField(QUERY_FIELD_DEPARTMENT,deptOid,queryMap,pageHelper,true);
    }
     /**
     * 查询某个角色下的用户对象
     * @param roleOid 角色的主键
     * @param queryMap 查询条件,如果是角色的某个属性作为查询条件,则可以使用pkRole.xxx这样的方式
     * @return 用户的显示对象列表
     * @throws VciBaseException 参数为空或者查询出错的时候会抛出异常
     */
    @Override
    public List<SmUserVO> listUserByRoleOid(String roleOid,
            Map<String, String> queryMap) throws VciBaseException {
        if(StringUtils.isBlank(roleOid)){
            return new ArrayList<>();
        }
        return listUserByQueryField(QUERY_FIELD_ROLE,roleOid,queryMap,false);
 
    }
    /**
     * 查询某个角色下的用户对象列表
     * @param roleOid 角色的主键
     * @param queryMap 查询条件,如果是角色的某个属性作为查询条件,则可以使用pkRole.xxx这样的方式
     * @param pageHelper 分页和排序信息,默认使用用户名升序排列
     * @return 用户的显示对象列表,默认使用用户名升序排列
     * @throws VciBaseException 参数为空或者查询出错的时候会抛出异常
     */
    @Override
    public DataGrid<SmUserVO> gridUserByRoleOid(String roleOid,
            Map<String, String> queryMap, PageHelper pageHelper)
            throws VciBaseException {
        return gridUserByQueryField(QUERY_FIELD_ROLE,roleOid,queryMap,pageHelper,false);
    }
    /**
     * 查询不在某个角色下的用户对象列表
     * @param roleOid 角色的主键
     * @param queryMap 查询条件,如果是角色的某个属性作为查询条件,则可以使用pkRole.xxx这样的方式
     * @return 用户的显示对象列表,默认使用用户名升序排列
     * @throws VciBaseException 参数为空或者查询出错的时候会抛出异常
     */
    @Override
    public List<SmUserVO> listUserUnInRoleOid(String roleOid,
            Map<String, String> queryMap) throws VciBaseException {
        if(StringUtils.isBlank(roleOid)){
            return new ArrayList<>();
        }
        return listUserByQueryField(QUERY_FIELD_ROLE,roleOid,queryMap,true);
    }
     /**
     * 查询不在某个角色下的用户对象列表
     * @param roleOid 角色的主键
     * @param queryMap 查询条件,如果是角色的某个属性作为查询条件,则可以使用pkRole.xxx这样的方式
     * @param pageHelper 分页和排序信息,默认使用用户名升序排列
     * @return 用户的显示对象列表,默认使用用户名升序排列
     * @throws VciBaseException 参数为空或者查询出错的时候会抛出异常
     */
    @Override
    public DataGrid<SmUserVO> gridUserUnInRoleOid(String roleOid,
            Map<String, String> queryMap, PageHelper pageHelper)
            throws VciBaseException {
        return gridUserByQueryField(QUERY_FIELD_ROLE,roleOid,queryMap,pageHelper,true);
    }
    /**
     * 批量根据角色的主键获取用户
     * @param roleOidCollection 角色的主键集合
     * @return 角色主键和对应的用户显示对象列表的映射,key角色的主键,value是这个角色下的用户
     * @throws VciBaseException 参数为空或者查询出错的时候会抛出异常
     */
    @Override
    public Map<String, List<SmUserVO>> batchListUserByRoleOids(
            Collection<String> roleOidCollection) throws VciBaseException {
        if(CollectionUtils.isEmpty(roleOidCollection)){
            return new HashMap<>();
        }
        List<SmUserVO> userVOList = listUserByQueryField(QUERY_FIELD_ROLE,roleOidCollection.stream().collect(Collectors.joining(",")),null,false );
        //需要查询每个角色和用户的关联信息
        Map<String,List<String>> roleHasUserOids = new HashMap<>();
        VciBaseUtil.switchCollectionForOracleIn(roleOidCollection).stream().forEach(roleOids->{
            String sql = " select plroleuid,pluseruid from pluserrole where plroleuid in (" + VciBaseUtil.toInSql(roleOids.toArray(new String[0])) + ")";
            List<Map> dataMap = boService.queryBySqlForMap(sql, null);
            if(!CollectionUtils.isEmpty(dataMap)){
                dataMap.stream().forEach(data->{
                    String roleOid = (String)data.get("plroleuid");
                    List<String> userOids = roleHasUserOids.getOrDefault(roleOid,new ArrayList<>());
                    userOids.add((String)data.get("pluseruid"));
                    roleHasUserOids.put(roleOid,userOids);
                });
            }
        });
        if(!CollectionUtils.isEmpty(userVOList)){
            //需要查询每个角色和用户的关联信息
            Map<String, SmUserVO> userVOMap = userVOList.stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
            Map<String,List<SmUserVO>> roleHasUserVOMap = new HashMap<>();
            roleHasUserOids.forEach((roleOid,userOids)->{
                List<SmUserVO> userVOS = new ArrayList<>();
                userOids.stream().forEach(userOid->{
                    if(userVOMap.containsKey(userOid)){
                        userVOS.add(userVOMap.get(userOid));
                    }
                });
                roleHasUserVOMap.put(roleOid,userVOS);
            });
            return roleHasUserVOMap;
        }
        return new HashMap<>();
    }
 
    /**
     * 参照生效的用户
     * @param queryMap 查询条件
     * @param pageHelper 分页对象
     * @return 用户的显示对象,默认使用用户名升序排列
     * @throws VciBaseException 查询出错的时候会抛出异常
     */
    @Override
    public DataGrid<SmUserVO> refGridUsers(Map<String, String> queryMap,
            PageHelper pageHelper) throws VciBaseException {
        return gridUserByQueryField(null,null,queryMap,pageHelper,false);
    }
    /**
     * 参照用户的树形显示
     * @param treeQueryObject 树型接口查询对象
     * @return 用户的树形信息,里面会包含用户对象里的所有属性
     * @throws VciBaseException 查询出错的时候会抛出异常
     */
    @Override
    public List<Tree> refTreeUsers(TreeQueryObject treeQueryObject)
            throws VciBaseException {
        VciQueryWrapperForDO queryWrapper = getQueryWrapper(null, null, treeQueryObject.getConditionMap(), null, false);
        queryWrapper.wrapperSql();
        String sql =  queryWrapper.getSelectFieldSql();
        String fromSql = " from pluser " + queryWrapper.getTableNick()
                + " left join pluserdept up on " + queryWrapper.getTableNick() + ".pluid = up.pluseruid left join pldept pkDepartment on  up.pldeptuid = pkDepartment.pluid " +
                " left join PLUSERPASSWORDSTRATEGY pkUserPassword on  " +queryWrapper.getTableNick() + ".pluid = pkUserPassword.pluseruid " +
                queryWrapper.getLinkTableSql() + (StringUtils.isNotBlank(queryWrapper.getWhereSql())?(" where " + queryWrapper.getWhereSql()):"");
        List<com.vci.client.bof.ClientBusinessObject> dataList = boService.queryBySql(sql + fromSql, null);
        List<Tree> treeList = new ArrayList<>();
        if(!CollectionUtils.isEmpty(dataList)){
            dataList.stream().forEach(cbo->{
                Tree tree = new Tree();
                tree.setOid(cbo.getOid());
                tree.setText(cbo.getId() + " " + cbo.getName());
                Map<String,String> attributeMap = new HashMap<>();
                WebUtil.copyValueToCboFromMap(cbo,attributeMap);
                tree.setAttributes(attributeMap);
                tree.setLeaf(true);
                treeList.add(tree);
            });
        }
        return treeList;
    }
     /**
     * 校验密码是否相同,在新平台中存储的密码是两次md5
     * @param userOid 用户主键
     * @param md5Password 已经md5加密一次的密码--老的平台里不能加密
     * @return true 表示相等,false表示不相等
     */
    @Override
    public boolean checkPasswordEqual(String md5Password, String userOid) {
        if(StringUtils.isBlank(md5Password) || StringUtils.isBlank(userOid)){
            return false;
        }
        String sql = " select plpassword from pluser where pluid = :userOid";
        Map<String,String> conditionMap = new HashMap<>();
        conditionMap.put("userOid",userOid.trim());
        List<com.vci.client.bof.ClientBusinessObject> clientBusinessObjectList = boService.queryBySql(sql, conditionMap);
        if(CollectionUtils.isEmpty(clientBusinessObjectList)){
            return  false;
        }
 
        ThreeDES des = new ThreeDES();// 实例化一个对�?
        des.getKey("daliantan0v0");// 生成密匙
        md5Password = des.getEncString(md5Password);
        if(md5Password.equals(clientBusinessObjectList.get(0).getAttributeValue("plpassword"))){
            return true;
        }
        return false;
    }
    /**
     * 校验用户是否锁定
     * @param smUserVO 用户对象
     * @param wrongCount 密码错误次数,如果wrongCount为空时,会校验用户本身是否已经锁定了
     * @return true表示已经锁定
     */
    @Override
    public boolean checkUserLock(SmUserVO smUserVO, Integer wrongCount) {
        if(wrongCount == null || wrongCount == 0){
            return smUserVO.isLockFlag();
        }
        //查询密码策略
        SmPasswordStrategyVO passwordStrategyVO = getPasswordStrategyVOByOid(smUserVO.getPkPasswordStrategy());
        if(passwordStrategyVO == null){
            throw new VciBaseException("系统里没有密码安全策略");
        }
        if(wrongCount >= passwordStrategyVO.getRetryTime()){
            return  true;
        }
        return false;
    }
 
    /**
     * 使用主键获取密码策略
     * @param oid 主键
     * @return 密码策略显示对象
     */
    public SmPasswordStrategyVO getPasswordStrategyVOByOid(String oid){
        VciQueryWrapperForDO queryWrapperForDO = new VciQueryWrapperForDO(null, SmPasswordStrategyDO.class);
        queryWrapperForDO.eq("oid",oid.trim());
        List<com.vci.client.bof.ClientBusinessObject> cboList = boService.queryBySql(queryWrapperForDO.getSelectFieldSql() + " from plpasswordstrategy " +
                queryWrapperForDO.getTableNick() + queryWrapperForDO.getLinkTableSql() +
                (StringUtils.isBlank(queryWrapperForDO.getWhereSql()) ? "" : (" where " + queryWrapperForDO.getWhereSql())), null);
        if(!CollectionUtils.isEmpty(cboList)){
            SmPasswordStrategyDO passwordStrategyDO = new SmPasswordStrategyDO();
            WebUtil.copyValueToObjectFromCbos(cboList.get(0),passwordStrategyDO);
            SmPasswordStrategyVO passwordStrategyVO = new SmPasswordStrategyVO();
            BeanUtil.convert(passwordStrategyDO,passwordStrategyVO);
            return passwordStrategyVO;
        }else{
            //获取默认的
            queryWrapperForDO = new VciQueryWrapperForDO(null, SmPasswordStrategyDO.class);
            queryWrapperForDO.eq("plisdefault","1");
            cboList = boService.queryBySql(queryWrapperForDO.getSelectFieldSql() + " from plpasswordstrategy " +
                    queryWrapperForDO.getTableNick() + queryWrapperForDO.getLinkTableSql() +
                    (StringUtils.isBlank(queryWrapperForDO.getWhereSql()) ? "" : (" where " + queryWrapperForDO.getWhereSql())), null);
            if(!CollectionUtils.isEmpty(cboList)){
                SmPasswordStrategyDO passwordStrategyDO = new SmPasswordStrategyDO();
                WebUtil.copyValueToObjectFromCbos(cboList.get(0),passwordStrategyDO);
                SmPasswordStrategyVO passwordStrategyVO = new SmPasswordStrategyVO();
                BeanUtil.convert(passwordStrategyDO,passwordStrategyVO);
                return passwordStrategyVO;
            }
        }
        return null;
    }
 
    /**
     * 根据用户的主键,获取用户的密码安全策略
     * @param userOid 用户的主键
     * @return 密码安全策略的显示对象,如果不存在则会返回Null
     * @throws VciBaseException 参数为空或者数据库查询出错的时候会抛出异常
     */
    @Override
    public SmPasswordStrategyVO getPasswordStrategyVOByUserOid(String userOid)
            throws VciBaseException {
        WebUtil.alertNotNull(userOid,"用户的主键");
        SmUserVO userVO = getUserByUserOid(userOid);
        if(userVO == null || StringUtils.isBlank(userVO.getOid())){
            throw new VciBaseException(DATA_OID_NOT_EXIST);
        }
        return getPasswordStrategyVOByOid(userVO.getPkPasswordStrategy());
    }
 
    /**
     * 设置某个用户是锁定状态
     * @param userId 用户名
     */
    @Override
    public void lockUser(String userId) {
        //老的这个平台,是依靠锁定次数来判断的,所以这里没办法直接设置
    }
     /**
     * 设置某个用户不是锁定状态
     * @param userId 用户名
     */
    @Override
    public void unLockUser(String userId) {
        WebUtil.alertNotNull(userId,"用户名");
        String sql = "update pllogoninfo set plwrongnum = 0 where pluserid in (select pluid from pluser where plusername='" + userId + "')";
        try {
            platformClientUtil.getBOFactoryService().executeUpdateSql(sql);
        } catch (PLException vciError) {
            throw WebUtil.getVciBaseException(vciError);
        }
    }
     /**
     * 修改密码
     * @param userOid 用户主键
     * @param password 新的密码
     * @param confirmPassword 确认密码
     */
    @Override
    public void changePassword(String userOid, String password,
            String confirmPassword) throws VciBaseException {
        WebUtil.alertNotNull(userOid,"用户主键",password,"密码",confirmPassword,"确认密码");
        if(!password.equals(confirmPassword)){
            throw new VciBaseException("密码和确认密码不相等");
        }
        ThreeDES des = new ThreeDES();// 实例化一个对�?
        des.getKey("daliantan0v0");// 生成密匙
        String encPassword = des.getEncString(password);
        String sql = "update pluser set plpassword = '" + encPassword + "' where pluid = '" + userOid.trim() + "'";
        try {
            platformClientUtil.getBOFactoryService().executeUpdateSql(sql);
        } catch (PLException vciError) {
            throw WebUtil.getVciBaseException(vciError);
        }
    }
    /**
     * 更新用户的密码错误次数
     * @param userOid 用户的主键
     * @param wrongCount 密码的错误次数
     * @throws VciBaseException 参数为空或者存储到数据库中出错的时候会抛出异常
     */
    @Override
    public void updateUserPwdWrongCount(String userOid, int wrongCount)
            throws VciBaseException {
        WebUtil.alertNotNull(userOid,"用户主键");
        String sql = "update pllogoninfo set plwrongnum = " + wrongCount +" where pluserid ='" + userOid + "'";
        try {
            platformClientUtil.getBOFactoryService().executeUpdateSql(sql);
        } catch (PLException vciError) {
            throw WebUtil.getVciBaseException(vciError);
        }
    }
     /**
     * 更新用户的最后登录时间
     * @param userOid 用户的主键
     * @throws VciBaseException 参数为空的时候会抛出异常
     */
    @Override
    public void updateUserLoginTime(String userOid) throws VciBaseException {
        WebUtil.alertNotNull(userOid,"用户主键");
        String sql = "update pllogoninfo set pllogontime = sysdate where pluserid ='" + userOid + "'";
        try {
            platformClientUtil.getBOFactoryService().executeUpdateSql(sql);
        } catch (PLException vciError) {
            throw WebUtil.getVciBaseException(vciError);
        }
    }
}