package com.vci.frameworkcore.compatibility.impl;

import com.vci.client.common.providers.ClientServiceProvider;
import com.vci.common.util.ThreeDES;
import com.vci.corba.common.PLException;
import com.vci.corba.framework.data.UserInfo;
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.enumpck.UserSecretEnum;
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.util.VciDateUtil;
import com.vci.starter.web.wrapper.VciQueryWrapperForDO;
import com.vci.web.enumpck.UserTypeEnum;
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.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";

	/**
     *  根据用户名获取用户的对象，不区分大小写
     * @param userId 用户名
     * @return 用户的显示对象，如果用户不存在则返回null，不会抛出异常
     * @throws VciBaseException 参数为空或者数据库存在问题的时候会抛出异常
     */
	@Override
	public SmUserVO getUserByUserId(String userId) throws VciBaseException {
		WebUtil.alertNotNull(userId,"用户名");
        try {
            UserInfo userInfo = platformClientUtil.getFrameworkService().getUserObjectByUserName(userId);
			return userInfo2VO(userInfo);
        } catch (PLException e) {
            throw new VciBaseException("登录时，获取用户信息失败："+e.getMessage());
        }
	}

	/**
	 * 业务数据转换为显示对象
	 * @param userInfo 平台返回的业务数据
	 * @return 用户显示对象
	 */
	private SmUserVO userInfo2VO(UserInfo userInfo) {
		SmUserVO smUserVO = new SmUserVO();
		smUserVO.setOid(userInfo.id);
		smUserVO.setId(userInfo.userName);
		smUserVO.setName(userInfo.trueName);
		smUserVO.setSecretGrade(userInfo.secretGrade);
		smUserVO.setSecretGradeText(UserSecretEnum.getSecretText(smUserVO.getSecretGrade()));
		smUserVO.setUserType(String.valueOf(userInfo.userType));
		smUserVO.setUserTypeText(UserTypeEnum.getTextByValue(smUserVO.getUserType()));
		smUserVO.setDescription(userInfo.desc);
		smUserVO.setEmail(userInfo.email);
		if(userInfo.status == 0){
			smUserVO.setLockFlag(false);
		}else{
			smUserVO.setLockFlag(true);
		}
		smUserVO.setCreator(userInfo.createUser);
		smUserVO.setCreateTime(VciDateUtil.long2Date(userInfo.createTime));
		smUserVO.setLastModifier(userInfo.updateUser);
		smUserVO.setLastLoginTime(VciDateUtil.long2Date(userInfo.updateTime));
		smUserVO.setLastModifyPasswordTime(VciDateUtil.long2Date(userInfo.pwdUpdateTime));
		return smUserVO;
	}

	/**
	 * 使用字段获取用户的信息
	 * @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 = ClientServiceProvider.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,"用户名集合");
		try {
			UserInfo[] userInfo = platformClientUtil.getFrameworkService().fetchUserInfoByNames(VciBaseUtil.collection2StrArr(userIdCollections));
			return userInfoArr2VO(userInfo);
		} catch (PLException e) {
			throw new VciBaseException("获取用户失败："+e.getMessage());
		}
	}
	/**
     * 根据用户主键获取用户的信息
     * @param userOid 用户主键
     * @return 用户的显示对象，如果用户不存在则返回null，不会抛出异常
     * @throws VciBaseException 参数为空或者数据库存在问题的时候会抛出异常
     */
	@Override
	public SmUserVO getUserByUserOid(String userOid) throws VciBaseException {
		WebUtil.alertNotNull(userOid,"用户主键");
        try {
            UserInfo userInfo = platformClientUtil.getFrameworkService().getUserObjectByoid(userOid);
			return userInfo2VO(userInfo);
        } catch (PLException e) {
            throw new VciBaseException("获取用户失败："+e.getMessage());
        }
	}
	 /**
     * 批量获取用户的信息 （根据用户主键）
     * @param userOidCollections 用户主键的集合，可以超过1000个
     * @return 用户的显示对象，如果用户不存在则返回空的列表，不会抛出异常
     * @throws VciBaseException 参数为空或者数据库存在问题的时候会抛出异常
     */
	@Override
	public List<SmUserVO> listUserByUserOids(
			Collection<String> userOidCollections) throws VciBaseException {
		WebUtil.alertNotNull(userOidCollections,"用户主键集合");
        try {
            UserInfo[] userInfoArr = platformClientUtil.getFrameworkService().getUserObjectByoids(VciBaseUtil.collection2StrArr(userOidCollections));
			return userInfoArr2VO(userInfoArr);
        } catch (PLException e) {
            throw new VciBaseException("获取用户信息失败:"+e.getMessage());
        }
	}

	/**
	 * 业务数据数组转显示对象集合
	 * @param userInfoArr 业务数据数组
	 * @return 显示对象集合
	 */
	private List<SmUserVO> userInfoArr2VO(UserInfo[] userInfoArr) {
		List<SmUserVO> userVOList = new ArrayList<>();
		for(UserInfo userInfo : userInfoArr){
			userVOList.add(userInfo2VO(userInfo));
		}
		return userVOList;
	}

	/**
	 * 用户的数据对象转换为显示对象
	 * @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 = getUserByUserId(userId);
		return userVO == null?"":userVO.getName();
	}
	 /**
     * 根据用户主键获取用户的姓名
     * @param userOid 用户主键
     * @return 用户姓名，如果不存在会返回null
     */
	@Override
	public String getUserNameByUserOid(String userOid) {
		SmUserVO userVO = 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);
		}
	}
}