Source/plt-web/plt-web-parent/plt-web/src/main/java/com/vci/frameworkcore/compatibility/impl/SmUserQueryServiceImpl.java

@@ -122,7 +122,7 @@
   /**
    * 用户分页查询时获取部门放到这里避免重复查询
    */
   private Map<String,List<OrgDepartmentVO>> orgDepartmentVOMap;
   private Map<String,Map<String,String>> orgDepartmentVOMap;

   /**
    * 用户分页查询时获取角色放到这里避免重复查询
@@ -320,22 +320,21 @@
      smUserVO.setEmail(userInfo.email);
      smUserVO.setStatus(userInfo.status);
      smUserVO.setPassword(userInfo.pwd);
      smUserVO.setConfirmPassword(userInfo.pwd);
      //用户所属部门的查询设置
      List<OrgDepartmentVO> orgDepartmentVOList;
      Map<String,String> orgDepartmentVOList;
      //查看全局变量中是否存在部门信息，存在的情况最主要是针对多条用户查询的时候避免重复查询的
      if(Func.isNotEmpty(orgDepartmentVOMap)){
         orgDepartmentVOList = orgDepartmentVOMap.get(userInfo.id);
         orgDepartmentVOList = Func.isNotEmpty(orgDepartmentVOMap.get(userInfo.id)) ?
               orgDepartmentVOMap.get(userInfo.id):new HashMap<>();
      }else {
         orgDepartmentVOList = orgDeptQueryService.listDeptByUserOid(userInfo.id,null);
         Map<String, Map<String, String>> tempDeptMap = orgDeptQueryService.batchMapDeptNameByUserOids(Arrays.asList(userInfo.id), null);
         orgDepartmentVOList = Func.isNotEmpty(tempDeptMap.get(userInfo.id)) ?
               tempDeptMap.get(userInfo.id):new HashMap<>();
      }
      smUserVO.setPkDepartment(
            Func.isEmpty(orgDepartmentVOList) ?
                  null:orgDepartmentVOList.stream().map(OrgDepartmentVO::getOid).collect(Collectors.joining(","))
      );
      smUserVO.setPkDepartmentName(
            Func.isEmpty(orgDepartmentVOList) ?
                  null:orgDepartmentVOList.stream().map(OrgDepartmentVO::getName).collect(Collectors.joining(","))
      );
      //部门oid，正常情况下一个用户只会存在一个部门下
      smUserVO.setPkDepartment(orgDepartmentVOList.keySet().stream().collect(Collectors.joining(",")));
      smUserVO.setPkDepartmentName(orgDepartmentVOList.values().stream().collect(Collectors.joining(",")));
      //密码策略查询设置
      SmPasswordStrategyVO smPasswordStrategyVO;
      if(Func.isNotEmpty(smPwdStrategyVOMap)){
@@ -508,19 +507,6 @@
   }

   /**
     * 获取用户的列表，默认会以用户名升序排列，用户的编辑页面列表不要使用这个接口
     * @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);
   }

   /**
    * 用户管理界面分页查询
    * @param conditionMap 查询条件
    * @param pageHelper 分页参数
@@ -532,8 +518,8 @@
         pageHelper = new PageHelper(-1);
      }
      pageHelper.addDefaultAsc("PLTRUENAME");
      //TODO:为了方便调试，所以这儿先注释写死后面记得更改
      String loginUserId = WebThreadLocalUtil.getCurrentUserSessionInfoInThread().getUserId();
      //String loginUserId = "Ludc";
      //分页查询
      UserInfo[] userInfos = platformClientUtil.getFrameworkService().fetchUserInfoByCondition(
            conditionMap.get("name"),
@@ -547,10 +533,11 @@
      DataGrid<SmUserVO> dataGrid = new DataGrid<>();
      if(Func.isNotEmpty(userInfos)){
         List<String> idList = Arrays.stream(userInfos).map(item -> item.id).collect(Collectors.toList());
         orgDepartmentVOMap = orgDeptQueryService.batchListDeptByUserOids(idList, null);
         orgDepartmentVOMap = orgDeptQueryService.batchMapDeptNameByUserOids(idList, null);
         smRoleVOMap = smRoleQueryService.batchListRoleByUserOids(idList,null);
         smPwdStrategyVOMap = smPwdStrategyQueryService.batchSmPwdStrategyByUserOids(idList);
         dataGrid.setData(userInfoArr2VO(userInfos));
         //TODO: 这个统计总数有问题，带过去的参数不能像上面那个fetchUserInfoByCondition查询一样统计增却的总数
         dataGrid.setTotal(
               platformClientUtil.getFrameworkService().getUserTotalByCondition(
                  conditionMap.get("name"),
@@ -607,24 +594,128 @@
      return userVO.getName();
   }

   /**
    * 统计部门下的用户：包含子部门下的用户
    * @param deptOid
    * @param queryMap
    * @return
    * @throws VciBaseException
    */
   @Override
   public List<SmUserVO> countSmUserByDeptOid(String deptOid, Map<String, String> queryMap) throws VciBaseException {
      //是否查询子部门下关联的用户
      List<OrgDepartmentVO> orgDepartmentVOList = orgDeptQueryService.listAllLevelChildrenDeptByParentOid(deptOid, null);
      List<String> deptOidCollection = orgDepartmentVOList.stream().map(OrgDepartmentVO::getOid).collect(Collectors.toList());
      deptOidCollection.add(deptOid);//将当前层的oid也放进去
      List<SmUserVO> smUserVOList = listUserVOByDeptOid(queryMap, deptOidCollection, false);
      if(Func.isEmpty(smUserVOList)){
         return new ArrayList<>();
      }
      Map<String, List<SmRoleVO>> smRoleVOMap = smRoleQueryService.batchListRoleByUserOids(smUserVOList.stream().map(SmUserVO::getOid).collect(Collectors.toSet()), null);
      smUserVOList = smUserVOList.stream().map(vo->{
         List<SmRoleVO> smRoleVOS = smRoleVOMap.get(vo.getOid());
         vo.setPkPerson(
               Func.isEmpty(smRoleVOS) ?
                     null:smRoleVOS.stream().map(SmRoleVO::getOid).collect(Collectors.joining(","))
         );
         vo.setPkPersonName(
               Func.isEmpty(smRoleVOS) ?
                     null:smRoleVOS.stream().map(SmRoleVO::getName).collect(Collectors.joining(","))
         );
         return vo;
      }).collect(Collectors.toList());
      return smUserVOList;
   }

    /**
     * 查询某个部门下的用户对象
     * 查询在某个部门下的用户对象
     * @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);
   public List<SmUserVO> listUserByDeptOid(String deptOid, Map<String, String> queryMap) throws VciBaseException {
      //查询当前选中的部门下的用户
      return listUserVOByDeptOid(queryMap,Arrays.asList(deptOid),false );
   }

   /**
    * 获取查询封装器，默认只查了plstatus=0和plusertype=2，排序默认plusername
    * 查询不在某个部门下的用户对象列表
    * @param deptOid 部门的主键
    * @param queryMap 查询条件，如果是部门的某个属性作为查询条件，则可以使用pkDepartment.xxx这样的方式
    * @return 用户的显示对象列表，默认使用用户名升序排列
    * @throws VciBaseException 参数为空或者查询出错的时候会抛出异常
    */
   @Override
   public List<SmUserVO> listUserUnInDeptOid(String deptOid, Map<String, String> queryMap) throws VciBaseException {
      // TODO:根据当前登录的用户决定能查那些用户
      String userType = "0";//WebThreadLocalUtil.getCurrentUserSessionInfoInThread().getUsertype();
      //根据当前登录的用户类型不同，查询不同的用户
      if(UserTypeEnum.SUPPER_ADMIN.getValue().equals(userType)){
         //超管用户只能查管理员用户
         queryMap.put("plusertype", "1");
      }else{
         //除了超管都只能查普通用户
         queryMap.put("plusertype", "2");
      }
      return listUserVOByDeptOid(queryMap,Arrays.asList(deptOid),true);
   }

   /**
    * 用户根据部门查询的统一方法
    * @param conditionMap 查询条件
    * @param deptOidList 部门主键
    * @param notIn true待选，false已选
    * @return
    */
   private List<SmUserVO> listUserVOByDeptOid(Map<String,String> conditionMap/*放置查询条件*/,List<String> deptOidList,boolean notIn){
      //先查询已选人员oid
      List<String> userOidList = new ArrayList<>();
      WebUtil.switchCollectionForOracleIn(deptOidList).stream().forEach(deptOids->{
         String sql = "select pluseruid,pldeptuid from pluserdept where pldeptuid in (" + WebUtil.toInSql(deptOids.toArray(new String[0])) + ")";
         List<BusinessObject> cbos = boService.queryBySql(sql, null);
         //遍历出用户主键
         cbos.stream().forEach(cbo->{
            userOidList.add(ObjectTool.getNewBOAttributeValue(cbo,"pluseruid"));
         });
      });
      //根据用户oid查询用户
      VciQueryWrapperForDO queryWrapperForDO = new VciQueryWrapperForDO(conditionMap, SmUserDO.class);
      //添加连表查询条件
      queryWrapperForDO.setLinkTableSql(" left join pluserdept up on " + queryWrapperForDO.getTableNick() + ".pluid = up.pluseruid" +
            " left join pldept pkDepartment on  up.pldeptuid = pkDepartment.pluid " +
            " left join PLUSERPASSWORDSTRATEGY pkUserPassword on  " +queryWrapperForDO.getTableNick() + ".pluid = pkUserPassword.pluseruid ");
      queryWrapperForDO.setOrderSql("order by " + queryWrapperForDO.getTableNick() + ".pltrueName");
      List<SmUserDO> smUserDOList = new ArrayList<>();
      //userOidList为空时的两种情况
      if(Func.isEmpty(userOidList)){
         //如果是已选查询说明已选为空直接返回空
         if(!notIn){
            return new ArrayList<>();
         }
         //不是已选查询说明待选为空，直接查询用户
         smUserDOList.addAll(boService.selectByQueryWrapper(queryWrapperForDO, SmUserDO.class));
      }else{
         //已选查询，或待选查询，但是该部门存在相关配置
         WebUtil.switchCollectionForOracleIn(userOidList).stream().forEach(userOids->{
            //查询不在范围内的：待选人员
            if(notIn){
               queryWrapperForDO.notIn(queryWrapperForDO.getTableNick()+".pluid",WebUtil.toInSql(userOids.toArray(new String[0])));

            }else{
               //已选人员和统计
               queryWrapperForDO.in(queryWrapperForDO.getTableNick()+".pluid",WebUtil.toInSql(userOids.toArray(new String[0])));
            }
            smUserDOList.addAll(boService.selectByQueryWrapper(queryWrapperForDO, SmUserDO.class));
         });
      }
      return smUserDO2VOs(smUserDOList);
   }

   /**
    * 获取查询封装器，默认只查了plstatus=0和plusertype=2（改成根据当前登录的用户来决定查什么类型的用户），
    * 排序默认plusername
    * @param queryField 查询属性
    * @param queryValue 查询的值
    * @param queryMap  查询条件，如果是角色的属性，需要使用pkrole.xxx
@@ -655,24 +746,17 @@
      }
      addRoleQuerySql(queryMap,queryWrapperForDO);
      queryWrapperForDO.eq("plstatus", "0");
      queryWrapperForDO.eq("plusertype", "2");
      queryWrapperForDO.setDistinct(true);
      // TODO:根据当前登录的用户决定能查那些用户
      SessionInfo loginUser = WebThreadLocalUtil.getCurrentUserSessionInfoInThread();
      //根据当前登录的用户类型不同，查询不同的用户
      if(UserTypeEnum.SUPPER_ADMIN.getValue().equals(loginUser.getUsertype())){
         //超管用户只能查管理员用户
         queryMap.put("plusertype", "1");
      }else{
         //除了超管都只能查普通用户
         queryMap.put("plusertype", "2");
      }
      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);
   }

    /**
@@ -695,37 +779,6 @@
   }

   /**
     * 查询不在某个部门下的用户对象列表
     * @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这样的方式
@@ -735,26 +788,7 @@
   @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);
      return listUserVOByRoleOid(queryMap,roleOid,false);
   }

   /**
@@ -767,25 +801,54 @@
   @Override
   public List<SmUserVO> listUserUnInRoleOid(String roleOid,
         Map<String, String> queryMap) throws VciBaseException {
      if(StringUtils.isBlank(roleOid)){
         return new ArrayList<>();
      // TODO:根据当前登录的用户决定能查那些用户
      String usertype = WebThreadLocalUtil.getCurrentUserSessionInfoInThread().getUsertype();
      //根据当前登录的用户类型不同，查询不同的用户
      if(UserTypeEnum.SUPPER_ADMIN.getValue().equals(usertype)){
         //超管用户只能查管理员用户
         queryMap.put("plusertype", "1");
      }else{
         //除了超管都只能查普通用户
         queryMap.put("plusertype", "2");
      }
      return listUserByQueryField(QUERY_FIELD_ROLE,roleOid,queryMap,true);
      return listUserVOByRoleOid(queryMap,roleOid,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 conditionMap 查询条件
    * @param roleOid 角色主键
    * @param notIn true不在范围内，false再范围内
    * @return
    */
   private List<SmUserVO> listUserVOByRoleOid(Map<String,String> conditionMap,String roleOid,boolean notIn){
      //listUserByQueryField这个方法暂时不能满足我现在的查询需求，并且引用的地方较多，所以不太好改动
      //1、先查询与当前角色存在关联关系的用户
      String sql = "select pluseruid,plroleuid from pluserrole where plroleuid = '" + roleOid +"'";
      List<BusinessObject> cbos = boService.queryBySql(sql, null);
      List<String> userOidList = new ArrayList<>();
      if(CollectionUtils.isEmpty(cbos)){
         return new ArrayList<>();
      }
      //遍历出用户主键
      cbos.stream().forEach(cbo->{
         userOidList.add(ObjectTool.getNewBOAttributeValue(cbo,"pluseruid"));
      });
      //2、再查询用户
      VciQueryWrapperForDO queryWrapperForDO = new VciQueryWrapperForDO(conditionMap, SmUserDO.class);
      List<SmUserDO> smUserDOS = new ArrayList<>();
      queryWrapperForDO.setLinkTableSql(" left join pluserdept up on " + queryWrapperForDO.getTableNick() + ".pluid = up.pluseruid" +
            " left join pldept pkDepartment on  up.pldeptuid = pkDepartment.pluid " +
            " left join PLUSERPASSWORDSTRATEGY pkUserPassword on  " +queryWrapperForDO.getTableNick() + ".pluid = pkUserPassword.pluseruid ");
      WebUtil.switchCollectionForOracleIn(userOidList).stream().forEach(userOids->{
         if(notIn){
            queryWrapperForDO.notIn("pluid",WebUtil.toInSql(userOids.toArray(new String[0])));
         }else{
            queryWrapperForDO.in("pluid",WebUtil.toInSql(userOids.toArray(new String[0])));
         }
         smUserDOS.addAll(boService.selectByQueryWrapper(queryWrapperForDO, SmUserDO.class));
      });
      return smUserDO2VOs(smUserDOS);
   }

   /**
@@ -1037,14 +1100,20 @@
      smUserDTO.setPwdUpdateTime(date);
      smUserDTO.setStatus((short) 0);
      smUserDTO.setCreateTime(date);
      smUserDTO.setLastModifyTime(date);
      String loginUserName = WebThreadLocalUtil.getCurrentUserSessionInfoInThread().getUserId();
      smUserDTO.setCreator(loginUserName);
      //smUserDTO.setCreator("developer");
      smUserDTO.setLastModifier(loginUserName);
      //smUserDTO.setLastModifier("developer");
      SessionInfo loginUser = WebThreadLocalUtil.getCurrentUserSessionInfoInThread();
      String loginUserId = loginUser.getUserId();
      //用户类型，现在按照当前登录的用户决定他所添加的用户级别
      //超管添加的就是管理员
      if(UserTypeEnum.SUPPER_ADMIN.getValue().equals(loginUser.getUsertype())){
         smUserDTO.setUserType(Short.parseShort(UserTypeEnum.ADMIN.getValue()));
      }else {
         //管理员添加的就是普通用户
         smUserDTO.setUserType(Short.parseShort(UserTypeEnum.USER.getValue()));
      }
      smUserDTO.setCreator(loginUserId);
      smUserDTO.setLastModifier(loginUserId);
      UserInfo userInfo = changeSmUserDTOToUserInfo(smUserDTO);
      UserEntityInfo userEntityInfo = new UserEntityInfo(loginUserName, "");
      UserEntityInfo userEntityInfo = new UserEntityInfo(loginUserId, "");
      String oid = platformClientUtil.getFrameworkService().saveUser(userInfo, userEntityInfo);
      if (Func.isEmpty(oid)) {
         return false;
@@ -1052,7 +1121,6 @@
      if(Func.isNotBlank(smUserDTO.getPkDepartment())){
         //执行保存用户部门关联关系
         orgDeptQueryService.saveUsersDept(new String[]{oid},smUserDTO.getPkDepartment());
         //platformClientUtil.getFrameworkService().saveUserDept(new String[]{oid}, smUserDTO.getPkDepartment(), userEntityInfo);
      }
      return true;
   }
@@ -1082,14 +1150,16 @@
      if(Func.isEmpty(dbSmUserVO) || Func.isBlank(dbSmUserVO.getOid())){
         throw new PLException("500", new String[] { "当前修改的用户不存在"});
      }

      smUserDTO.setLastModifyTime(new Date());
      String loginUserName = WebThreadLocalUtil.getCurrentUserSessionInfoInThread().getUserId();
      SessionInfo loginUser = WebThreadLocalUtil.getCurrentUserSessionInfoInThread();
      String loginUserName = loginUser.getUserId();
      smUserDTO.setLastModifier(loginUserName);
      smUserDTO.setUserType(Short.parseShort(dbSmUserVO.getUserType()));
      smUserDTO.setPwdUpdateTime(dbSmUserVO.getLastModifyPasswordTime());
      smUserDTO.setIsDeptLeader(smUserDTO.getIsDeptLeader().equals("不是") ? "0":"1");
      UserInfo userInfo = changeSmUserDTOToUserInfo(smUserDTO);
      boolean updateBoolean = platformClientUtil.getFrameworkService().updateUser(userInfo, new UserEntityInfo(loginUserName, null));
      //修改成功，并且用户关联部门有所更改
      if(updateBoolean && Func.isNotEmpty(smUserDTO.getPkDepartment()) && !smUserDTO.getPkDepartment().equals(dbSmUserVO.getPkDepartment())){
      if(updateBoolean && !smUserDTO.getPkDepartment().equals(dbSmUserVO.getPkDepartment())){
         //执行保存用户部门关联关系
         orgDeptQueryService.saveUsersDept(new String[]{dbSmUserVO.getOid()},smUserDTO.getPkDepartment());
      }
@@ -1143,9 +1213,7 @@
      }
      //根据当前创建这个用户的人所绑定密码策略来进行密码校验
      try {
         //TODO:为了方便调试，所以这儿先注释写死后面记得更改
         //String userName = WebThreadLocalUtil.getCurrentUserSessionInfoInThread().getUserId();
         String userName = "developer";
         String userName = WebThreadLocalUtil.getCurrentUserSessionInfoInThread().getUserId();
         String error = platformClientUtil.getFrameworkService().checkPasswordStrategyByUserId(userName, smUserDTO.getPassword(),null);
         if (!StringUtils.isBlank(error)) {
            throw new VciBaseException("当前设置的密码，密码策略校验未通过");
@@ -1175,7 +1243,7 @@
      userInfo.status = user.getStatus();
      userInfo.createTime = user.getCreateTime().getTime();
      userInfo.createUser = user.getCreator() == null ? "" : user.getCreator();
      userInfo.updateTime = user.getLastModifyTime().getTime();
      userInfo.updateTime = System.currentTimeMillis();
      userInfo.updateUser = user.getLastModifier() == null ? "" : user.getLastModifier();
      userInfo.pwdUpdateTime = user.getPwdUpdateTime().getTime();
      userInfo.grantor = user.getGrantor() == null ? "" : user.getGrantor();
@@ -1191,11 +1259,12 @@
   @Override
   @Transactional(rollbackFor = Exception.class)
   public boolean deleteUser(String[] ids) throws PLException {
      if(Func.isEmpty(ids)){
         throw new VciBaseException("待删除的用户id列表不能为空！");
      }
      VciBaseUtil.alertNotNull(ids,"要删除的用户主键");
      //调用platformClientUtil的删除用户的方法，会一起删除掉具备关联关系的一些信息，如部门
      return platformClientUtil.getFrameworkService().deleteUser(ids, null);
      return platformClientUtil.getFrameworkService().deleteUser(
            ids,
            new UserEntityInfo(WebThreadLocalUtil.getCurrentUserSessionInfoInThread().getUserId(),null)
      );
   }

   /**
@@ -1219,6 +1288,8 @@
    */
   @Override
   public String downloadImportTemplate(String downloadFileName) {
      //界面没传名称，使用默认名称
      downloadFileName = Func.isBlank(downloadFileName) ?  "用户导入模板_" + Func.format(new Date(),"yyyy-MM-dd HHmmss.sss"):downloadFileName;
      // 设置表单列名
      List<String> columns = new ArrayList<>(Arrays.asList("账号", "密码", "姓名", "电子邮箱", "专业", "描述", "部门(上下级部门之间以反斜杠隔开(/))"));
      //获取是否导出密级配置项
@@ -1271,8 +1342,7 @@
         //1、读取excel中的数据，组成对象
         ReadExcelOption excelOption = new ReadExcelOption();
         //当前登录的用户账号
         //String loginUserId = WebThreadLocalUtil.getCurrentUserSessionInfoInThread().getUserId();
         String loginUserId = "developer";
         String loginUserId = WebThreadLocalUtil.getCurrentUserSessionInfoInThread().getUserId();
         UserEntityInfo userEntityInfo = new UserEntityInfo(loginUserId,null);
         //是否导入密级配置
         boolean exportSecretGrade = Boolean.parseBoolean(ConfigReader.getConfigValue("exportSecretGrade"));
@@ -1334,7 +1404,6 @@
            smUserDTO.setPwdUpdateTime(date);
            smUserDTO.setStatus((short) 0);
            smUserDTO.setCreateTime(date);
            smUserDTO.setLastModifyTime(date);
            smUserDTO.setCreator(loginUserId);
            smUserDTO.setLastModifier(loginUserId);
            //保存用户