package com.vci.frameworkcore.compatibility.impl;

import com.vci.corba.common.PLException;
import com.vci.corba.common.data.UserEntityInfo;
import com.vci.corba.omd.data.BusinessObject;
import com.vci.frameworkcore.compatibility.SmRoleQueryServiceI;
import com.vci.frameworkcore.constant.FrameWorkBtmTypeConstant;
import com.vci.frameworkcore.enumpck.RoleClassifyEnum;
import com.vci.frameworkcore.enumpck.RoleControlAreaEnum;
import com.vci.frameworkcore.model.SmRoleForPlatform1;
import com.vci.frameworkcore.pagemodel.OrgDepartmentVO;
import com.vci.frameworkcore.pagemodel.SmRoleVO;
import com.vci.omd.utils.ObjectTool;
import com.vci.starter.web.constant.QueryOptionConstant;
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.VciBaseUtil;
import com.vci.starter.web.wrapper.VciQueryWrapperForDO;
import com.vci.web.properties.WebProperties;
import com.vci.web.service.WebBoServiceI;
import com.vci.web.util.Func;
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.function.Function;
import java.util.stream.Collectors;

import static com.vci.frameworkcore.constant.FrameWorkBusLangCodeConstant.DATA_OID_NOT_EXIST;

/**
 * 角色的查询服务，兼容来平台，素有的接口都返回新的角色显示对象
 * @author xiejun
 * @date 2020/3/10
 */
@Service
public class SmRoleQueryServiceImpl implements SmRoleQueryServiceI {

	/**
	 * 业务数据服务
	 */
	@Autowired
	private WebBoServiceI boService;

	/**
	 * 平台调用客户端
	 */
	@Autowired
	private PlatformClientUtil platformClientUtil;

	/**
     * 根据角色主键获取角色的信息
     * @param roleOid 角色主键
     * @return 角色的显示对象，如果角色不存在则返回null，不会抛出异常
     * @throws VciBaseException 参数为空或者数据库存在问题的时候会抛出异常
     */
	@Override
	public SmRoleVO getRoleByRoleOid(String roleOid) throws VciBaseException {
		if(StringUtils.isBlank(roleOid)){
			return null;
		}
		SmRoleForPlatform1 role = boService.selectByOid(roleOid, SmRoleForPlatform1.class);
		if(role == null || StringUtils.isBlank(role.getPluid())){
			throw new VciBaseException(DATA_OID_NOT_EXIST);
		}
		return platformRole2SmRoleVO(role);
	}

	/**
     * 批量获取角色的信息 （根据角色主键）
     * @param roleOidCollections 角色主键的集合，可以超过1000个
     * @return 角色的显示对象，如果角色不存在则返回空的列表，不会抛出异常
     * @throws VciBaseException 参数为空或者数据库存在问题的时候会抛出异常
     */
	@Override
	public List<SmRoleVO> listRoleByRoleOids(
			Collection<String> roleOidCollections) throws VciBaseException {
		if(CollectionUtils.isEmpty(roleOidCollections)){
			return new ArrayList<>();
		}
		List<SmRoleForPlatform1> roles = new ArrayList<>();
		WebUtil.switchCollectionForOracleIn(roleOidCollections).stream().forEach(roleOids->{
			VciQueryWrapperForDO queryWrapper = new VciQueryWrapperForDO(null,SmRoleForPlatform1.class);
			queryWrapper.in("pluid", VciBaseUtil.toInSql(roleOids.toArray(new String[0])));
			List<SmRoleForPlatform1> roleForPlatform1s = boService.selectByQueryWrapper(queryWrapper, SmRoleForPlatform1.class);
			if(!CollectionUtils.isEmpty(roleForPlatform1s)){
				roles.addAll(roleForPlatform1s);
			}
		});
		return 	platformRole2SmRoleVOs(roles);
	}

	/**
     * 获取角色的列表，默认会以角色名升序排列，角色的编辑页面列表不要使用这个接口
     * @param queryMap 查询条件
     * @param pageHelper 分页和排序的信息，在兼容老平台的时候会自动兼容，如果属性不存在会自动忽略
     * @return 角色的显示对象列表
     * @throws VciBaseException 参数为空的时候会抛出异常
     */
	@Override
	public DataGrid<SmRoleVO> gridRoles(Map<String, String> queryMap, PageHelper pageHelper) throws VciBaseException {
		if(pageHelper == null){
			pageHelper = new PageHelper(-1);
		}
		pageHelper.addDefaultAsc("plname");
		VciQueryWrapperForDO queryWrapper = new VciQueryWrapperForDO(queryMap,SmRoleForPlatform1.class,pageHelper);
		//queryWrapper.eq("pltype","2");
		List<SmRoleForPlatform1> roleForPlatform1s = boService.selectByQueryWrapper(queryWrapper, SmRoleForPlatform1.class);
		DataGrid<SmRoleVO> dataGrid = new DataGrid<>();
		if(!CollectionUtils.isEmpty(roleForPlatform1s)){
			dataGrid.setData(platformRole2SmRoleVOs(roleForPlatform1s));
			dataGrid.setTotal(boService.countByQueryWrapper(queryWrapper,SmRoleForPlatform1.class));
		}
		return dataGrid;
	}

	 /**
     * 根据角色主键获取角色的姓名
     * @param roleOid 角色主键
     * @return 角色姓名，如果不存在会返回null
     */
	@Override
	public String getRoleNameByRoleOid(String roleOid) {
		WebUtil.alertNotNull(roleOid,"角色主键");
		return getRoleByRoleOid(roleOid).getName();
	}

	 /**
     * 根据用户主键获取关联的角色
     * @param userOid 用户主键
     * @param queryMap 查询条件，如果需要使用用户的属性来查询可以使用pkUser.xxxx
     * @return 角色的显示对象
     */
	@Override
	public List<SmRoleVO> listRoleByUserOid(String userOid,
			Map<String, String> queryMap) {
		return listRoleByUserOid(userOid,queryMap,false);
	}

	/**
	 * 使用用户主键查询角色
	 * @param userOid 用户主键
	 * @param queryMap 查询条件
	 * @param notIn 是否为不包含
	 * @return 角色的显示对象
	 */
	private List<SmRoleVO> listRoleByUserOid(String userOid,Map<String,String> queryMap,boolean notIn){
		if(StringUtils.isBlank(userOid)){
			return new ArrayList<>();
		}
		if(queryMap == null){
			queryMap = new HashMap<>();
		}
		List<SmRoleForPlatform1> roles = new ArrayList<>();
		if(userOid.contains(",")){
			Map<String, String> finalQueryMap = queryMap;
			WebUtil.switchCollectionForOracleIn(WebUtil.str2List(userOid)).stream().forEach(userOids->{
				Map<String,String> conditionMap = new HashMap<>();
				finalQueryMap.forEach((key,value)->{
					conditionMap.put(key,value);
				});
				conditionMap.put("pluid", notIn ? QueryOptionConstant.NOTIN : QueryOptionConstant.IN + "select plroleuid from pluserrole where pluseruid in (" + WebUtil.toInSql(userOids.toArray(new String[0])) + ")");
				VciQueryWrapperForDO queryWrapper = new VciQueryWrapperForDO(conditionMap,SmRoleForPlatform1.class);
				List<SmRoleForPlatform1> roleForPlatform1s = boService.selectByQueryWrapper(queryWrapper, SmRoleForPlatform1.class);
				if(!CollectionUtils.isEmpty(roleForPlatform1s)){
					roles.addAll(roleForPlatform1s);
				}
			});
		}else {
			queryMap.put("pluid", notIn ? QueryOptionConstant.NOTIN : QueryOptionConstant.IN + "select plroleuid from pluserrole where pluseruid ='" + userOid.trim() + "'");
		}
		VciQueryWrapperForDO queryWrapper = new VciQueryWrapperForDO(queryMap,SmRoleForPlatform1.class);
		List<SmRoleForPlatform1> roleForPlatform1s = boService.selectByQueryWrapper(queryWrapper, SmRoleForPlatform1.class);
		if(!CollectionUtils.isEmpty(roleForPlatform1s)){
			roles.addAll(roleForPlatform1s);
		}
		return platformRole2SmRoleVOs(roles);
	}

	  /**
     * 根据用户主键获取关联的角色
     * @param userOid 用户主键
     * @param queryMap 查询条件，如果需要使用用户的属性来查询可以使用pkUser.xxxx
     * @param pageHelper 分页和排序对象，老平台不支持使用角色编号来排序
     * @return 角色的显示对象
     */
	@Override
	public DataGrid<SmRoleVO> gridRoleByUserOid(String userOid,
			Map<String, String> queryMap, PageHelper pageHelper) {
		return gridRoleByUserOid(userOid,queryMap,pageHelper,false);
	}

	/**
	 * 使用用户查询角色列表
	 * @param userOid 用户主键
	 * @param queryMap 查询条件
	 * @param pageHelper 分页对象
	 * @param notIn 不包含
	 * @return 列表数据
	 */
	private DataGrid<SmRoleVO> gridRoleByUserOid(String userOid,Map<String,String> queryMap,PageHelper pageHelper,boolean notIn){
		if(queryMap == null){
			queryMap = new HashMap<>();
		}
		if(StringUtils.isBlank(userOid)){
			return new DataGrid<>();
		}
		if(userOid.contains(",")){
			String[] userOids = userOid.trim().split(",");
			if(userOids.length>1000){
				//这个方法不支持超过1000个的用户查询
				throw new VciBaseException("这个方法不支持超过1000个用户的主键来查询");
			}
			queryMap.put("pluid", notIn ? QueryOptionConstant.NOTIN : QueryOptionConstant.IN + "select plroleuid from pluserrole where pluseruid in (" + WebUtil.toInSql(userOids) + ")");
		}else {
			queryMap.put("pluid", notIn ? QueryOptionConstant.NOTIN : QueryOptionConstant.IN + "select plroleuid from pluserrole where pluseruid ='" + userOid.trim() + "'");
		}
		return gridRoles(queryMap,pageHelper);
	}

	 /**
     * 获取未关联某个用户的角色
     * @param userOid 用户主键
     * @param queryMap 查询条件，如果需要使用用户的属性来查询可以使用pkUser.xxxx
     * @return 角色的显示对象
     */
	@Override
	public List<SmRoleVO> listRoleUnInUserOid(String userOid,
			Map<String, String> queryMap) {
		return listRoleByUserOid(userOid,queryMap,true);
	}

	/**
     * 获取未关联某个用户的角色
     * @param userOid 用户主键
     * @param queryMap 查询条件，如果需要使用用户的属性来查询可以使用pkUser.xxxx
     * @param pageHelper 分页和排序对象，老平台不支持使用角色编号来排序
     * @return 角色的显示对象
     */
	@Override
	public DataGrid<SmRoleVO> gridRoleUninUserOid(String userOid,
			Map<String, String> queryMap, PageHelper pageHelper) {
		return gridRoleByUserOid(userOid,queryMap,pageHelper,true);
	}

	  /**
     * 批量根据用户的主键来获取角色
     * @param userOidCollection 用户主键集合
     * @param queryMap 查询条件，如果需要使用用户的属性来查询可以使用pkUser.xxxx
     * @return 角色的显示对象，key是用户主键,value是这个用户关联的角色
     */
	@Override
	public Map<String, List<SmRoleVO>> batchListRoleByUserOids(
			Collection<String> userOidCollection, Map<String, String> queryMap) {
		if(CollectionUtils.isEmpty(userOidCollection)){
			return new HashMap<>();
		}
		List<SmRoleVO> roleVOList = new ArrayList<>();
		Map<String,List<String>> userRoleOidMap = new HashMap<>();
		WebUtil.switchCollectionForOracleIn(userOidCollection).stream().forEach(userOids->{
			List<SmRoleVO> roleVOS = listRoleByUserOid(userOids.stream().collect(Collectors.joining(",")), queryMap, false);
			if(!CollectionUtils.isEmpty(roleVOS)){
				roleVOList.addAll(roleVOS);
				String sql = "select pluseruid,plroleuid from pluserrole where pluseruid in (" + WebUtil.toInSql(userOids.toArray(new String[0])) + ")";
				List<BusinessObject> cbos = boService.queryBySql(sql, null);
				if(!CollectionUtils.isEmpty(cbos)){
					cbos.stream().forEach(cbo->{
						String userOid = ObjectTool.getNewBOAttributeValue(cbo,"pluseruid");
						List<String> roleOids = userRoleOidMap.getOrDefault(userOid,new ArrayList<>());
						roleOids.add(ObjectTool.getNewBOAttributeValue(cbo,"plroleuid"));
						userRoleOidMap.put(userOid,roleOids);
					});
				}
			}
		});
		if(!CollectionUtils.isEmpty(roleVOList)){
			//这儿应该对roleVOList做一次去重处理，因为肯定会有重复的角色被查出来
			Map<String, SmRoleVO> roleVOMap = roleVOList.stream()
					.collect(Collectors.toMap(SmRoleVO::getOid, Function.identity(), (existing, replacement) -> existing));
			//Map<String, SmRoleVO> roleVOMap = roleVOList.stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
			Map<String, List<SmRoleVO>> userRoleVOMap = new HashMap<>();
			userRoleOidMap.forEach((userOid,roleOids)->{
				List<SmRoleVO> roleVOS = new ArrayList<>();
				roleOids.forEach(roleOid->{
					if(roleVOMap.containsKey(roleOid)){
						roleVOS.add(roleVOMap.get(roleOid));
					}
				});
				userRoleVOMap.put(userOid,roleVOS);
			});
			return userRoleVOMap;
		}
		return new HashMap<>();
	}

	 /**
     * 根据权限主键获取关联的角色
     * @param functionOid 权限主键
     * @param queryMap 查询条件
     * @return 角色的显示对象
     */
	@Override
	public List<SmRoleVO> listRoleByFunctionOid(String functionOid,
			Map<String, String> queryMap) {
		return listRoleByFunctionOid(functionOid,queryMap,false);
	}

	/**
	 * 使用用户主键查询角色
	 * @param functionOid 用户主键
	 * @param queryMap 查询条件
	 * @param notIn 是否为不包含
	 * @return 角色的显示对象
	 */
	private List<SmRoleVO> listRoleByFunctionOid(String functionOid,Map<String,String> queryMap,boolean notIn){
		if(StringUtils.isBlank(functionOid)){
			return new ArrayList<>();
		}
		if(queryMap == null){
			queryMap = new HashMap<>();
		}
		List<SmRoleForPlatform1> roles = new ArrayList<>();
		if(functionOid.contains(",")){
			Map<String, String> finalQueryMap = queryMap;
			WebUtil.switchCollectionForOracleIn(WebUtil.str2List(functionOid)).stream().forEach(functionOids->{
				Map<String,String> conditionMap = new HashMap<>();
				finalQueryMap.forEach((key,value)->{
					conditionMap.put(key,value);
				});
				conditionMap.put("pluid", notIn ? QueryOptionConstant.NOTIN : QueryOptionConstant.IN + "select plroleoid from plroleright where plfuncoid in (" + WebUtil.toInSql(functionOids.toArray(new String[0])) + ")");
				VciQueryWrapperForDO queryWrapper = new VciQueryWrapperForDO(conditionMap,SmRoleForPlatform1.class);
				List<SmRoleForPlatform1> roleForPlatform1s = boService.selectByQueryWrapper(queryWrapper, SmRoleForPlatform1.class);
				if(!CollectionUtils.isEmpty(roleForPlatform1s)){
					roles.addAll(roleForPlatform1s);
				}
			});
		}else {
			queryMap.put("pluid", notIn ? QueryOptionConstant.NOTIN : QueryOptionConstant.IN + "select plroleoid from plroleright where plfuncoid ='" + functionOid.trim() + "'");
			VciQueryWrapperForDO queryWrapper = new VciQueryWrapperForDO(queryMap,SmRoleForPlatform1.class);
			List<SmRoleForPlatform1> roleForPlatform1s = boService.selectByQueryWrapper(queryWrapper, SmRoleForPlatform1.class);
			if(!CollectionUtils.isEmpty(roleForPlatform1s)){
				roles.addAll(roleForPlatform1s);
			}
		}
		return platformRole2SmRoleVOs(roles);
	}

	/**
	 * 获取未关联某个权限的角色
	 * @param functionOid 权限主键
	 * @param queryMap 查询条件
	 * @param pageHelper 分页和排序对象，老平台不支持使用角色编号来排序
	 * @return 角色的显示对象
	 */
	@Override
	public DataGrid<SmRoleVO> gridRoleByFunctionOid(String functionOid,
			Map<String, String> queryMap, PageHelper pageHelper) {
		return gridRoleByFunctionOid(functionOid,queryMap,pageHelper,false);
	}

	/**
	 * 使用权限查询角色列表
	 * @param functionOid 权限主键
	 * @param queryMap 查询条件
	 * @param pageHelper 分页对象
	 * @param notIn 不包含
	 * @return 列表数据
	 */
	private DataGrid<SmRoleVO> gridRoleByFunctionOid(String functionOid,Map<String,String> queryMap,PageHelper pageHelper,boolean notIn){
		if(queryMap == null){
			queryMap = new HashMap<>();
		}
		if(StringUtils.isBlank(functionOid)){
			return new DataGrid<>();
		}
		if(functionOid.contains(",")){
			String[] functionOids= functionOid.trim().split(",");
			if(functionOids.length>1000){
				//这个方法不支持超过1000个的用户查询
				throw new VciBaseException("这个方法不支持超过1000个权限的主键来查询");
			}
			queryMap.put("pluid", notIn ? QueryOptionConstant.NOTIN : QueryOptionConstant.IN + "select plroleoid from plroleright where plfuncoid in (" + WebUtil.toInSql(functionOids) + ")");
		}else {
			queryMap.put("pluid", notIn ? QueryOptionConstant.NOTIN : QueryOptionConstant.IN + "select plroleoid from plroleright where plfuncoid ='" + functionOid.trim() + "'");
		}
		return gridRoles(queryMap,pageHelper);
	}

	/**
	 * 获取未关联某个权限的角色
	 * @param functionOid 权限主键
	 * @param queryMap 查询条件
	 * @return 角色的显示对象
	 */
	@Override
	public List<SmRoleVO> listRoleUnInFunctionOid(String functionOid,
			Map<String, String> queryMap) {
		return listRoleByFunctionOid(functionOid,queryMap,true);
	}

	/**
	 * 根据权限主键获取关联的角色
	 * @param functionOid 权限主键
	 * @param queryMap 查询条件
	 * @param pageHelper 分页和排序对象，老平台不支持使用角色编号来排序
	 * @return 角色的显示对象
	 */
	@Override
	public DataGrid<SmRoleVO> gridRoleUnInFunctionOid(String functionOid,
			Map<String, String> queryMap, PageHelper pageHelper) {
		return gridRoleByFunctionOid(functionOid,queryMap,pageHelper,true);
	}

	/**
	 * 批量根据权限的主键来获取角色
	 * @param functionOidCollection 权限主键集合
	 * @param queryMap 查询条件，如果需要使用用户的属性来查询可以使用pkUser.xxxx
	 * @return 角色的显示对象，key是权限主键,value是这个权限关联的角色
	 */
	@Override
	public Map<String, List<SmRoleVO>> batchListRoleByFunctionOids(
			Collection<String> functionOidCollection,
			Map<String, String> queryMap) {
		if(CollectionUtils.isEmpty(functionOidCollection)){
			return new HashMap<>();
		}
		List<SmRoleVO> roleVOList = new ArrayList<>();
		Map<String,List<String>> funcRoleOidMap = new HashMap<>();
		WebUtil.switchCollectionForOracleIn(functionOidCollection).stream().forEach(userOids->{
			List<SmRoleVO> roleVOS = listRoleByFunctionOid(userOids.stream().collect(Collectors.joining(",")), queryMap, false);
			if(!CollectionUtils.isEmpty(roleVOS)){
				roleVOList.addAll(roleVOS);
				String sql = "select plroleoid,plfuncoid from plroleright where plfuncoid in (" + WebUtil.toInSql(userOids.toArray(new String[0])) + ")";
				List<BusinessObject> cbos = boService.queryBySql(sql, null);
				if(!CollectionUtils.isEmpty(cbos)){
					cbos.stream().forEach(cbo->{
						String funcOid = ObjectTool.getBOAttributeValue(cbo,"plfuncoid");
						List<String> roleOids = funcRoleOidMap.getOrDefault(funcOid,new ArrayList<>());
						roleOids.add(ObjectTool.getBOAttributeValue(cbo,"plroleoid"));
						funcRoleOidMap.put(funcOid,roleOids);
					});
				}
			}
		});
		if(!CollectionUtils.isEmpty(roleVOList)){
			Map<String, SmRoleVO> roleVOMap = roleVOList.stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
			Map<String, List<SmRoleVO>> userRoleVOMap = new HashMap<>();
			funcRoleOidMap.forEach((funcOid,roleOids)->{
				List<SmRoleVO> roleVOS = new ArrayList<>();
				roleOids.forEach(roleOid->{
					if(roleVOMap.containsKey(roleOid)){
						roleVOS.add(roleVOMap.get(roleOid));
					}
				});
				userRoleVOMap.put(funcOid,roleVOS);
			});
			return userRoleVOMap;
		}
		return new HashMap<>();
	}

	 /**
     * 参照角色的列表，三员管理的三个角色不会显示
     * @param queryMap 查询条件
     * @param pageHelper 分页和排序的信息，在兼容老平台的时候会自动兼容，如果属性不存在会自动忽略
     * @return 角色的显示对象列表
     * @throws VciBaseException 参数为空的时候会抛出异常
     */
	@Override
	public DataGrid<SmRoleVO> refGridRoles(Map<String, String> queryMap,
			PageHelper pageHelper) throws VciBaseException {
		//老平台没有生效状态
		return gridRoles(queryMap, pageHelper);
	}

	  /**
     * 角色的树形展示，常用于角色选择用户的页面使用
     * @param treeQueryObject 树查询对象
     * @return 树的节点
     * @throws VciBaseException 参数为空的时候会抛出异常
     */
	@Override
	public List<Tree> refTreeRoles(TreeQueryObject treeQueryObject)
			throws VciBaseException {
		VciQueryWrapperForDO queryWrapper = new VciQueryWrapperForDO(treeQueryObject.getConditionMap(),SmRoleForPlatform1.class);
		queryWrapper.eq("pltype","2");
		List<SmRoleForPlatform1> roleForPlatform1s = boService.selectByQueryWrapper(queryWrapper, SmRoleForPlatform1.class);
		List<SmRoleVO> roleVOList = platformRole2SmRoleVOs(roleForPlatform1s);
		List<Tree> list=new ArrayList<Tree>();
		if(!CollectionUtils.isEmpty(roleVOList)){
			for (SmRoleVO smRoleVO : roleVOList) {
				 String name=smRoleVO.getName();
				 Tree tree=new Tree(smRoleVO.getOid(),name);
				 tree.setShowCheckbox(treeQueryObject.isShowCheckBox());
				 try {
					 tree.setAttributes(WebUtil.objectToMapString(smRoleVO));
				 } catch (Throwable e) {
					 e.printStackTrace();
				 }
				 list.add(tree);
			}
		}
		return list;
	}

	/**
	 * 该方法只支持一次只允许单个用户分配多个角色，一对多
	 * @param userOid
	 * @param roleIds
	 * @return
	 */
	@Override
	public boolean saveRights(String userOid, String[] roleIds) throws PLException {
		VciBaseUtil.alertNotNull(userOid,"用户主键");
		//roleIds允许为空，为空时清空当前用户的权限
		return platformClientUtil.getFrameworkService().saveRights(roleIds,new String[]{userOid},new UserEntityInfo());
	}

	/**
	 * 角色的转换，默认全部是bs控制的角色
	 * @param roleForPlatform1List 原平台的角色
	 * @return 角色的显示对象
	 */
	private List<SmRoleVO> platformRole2SmRoleVOs(List<SmRoleForPlatform1> roleForPlatform1List){
		List<SmRoleVO> roleVOList = new ArrayList<>();
		if(!CollectionUtils.isEmpty(roleForPlatform1List)){
			roleForPlatform1List.stream().forEach(s -> {
				roleVOList.add( platformRole2SmRoleVO(s));
			});
		}
		return roleVOList;
	}

	/**
	 * 角色的转换
	 * @param roleForPlatform1 原平台的角色
	 * @return 新的角色对象
	 */
	private SmRoleVO platformRole2SmRoleVO(SmRoleForPlatform1 roleForPlatform1){
		SmRoleVO roleVO = new SmRoleVO();
		roleVO.setOid(roleForPlatform1.getPluid());
		roleVO.setId("");
		roleVO.setName(roleForPlatform1.getPlname());
		if(roleForPlatform1.getPltype() == 1){
			roleVO.setRoleClassify(RoleClassifyEnum.MANAGE.getValue());
		}else{
			roleVO.setRoleClassify(RoleClassifyEnum.BUSINESS.getValue());
		}
		roleVO.setRoleClassifyText(RoleClassifyEnum.getTextByValue(roleVO.getRoleClassify()));
		roleVO.setRoleControlArea(RoleControlAreaEnum.BS.getValue());
		roleVO.setRoleClassifyText(RoleControlAreaEnum.BS.getText());
		roleVO.setCreateTime(roleForPlatform1.getPlcreatetime());
		roleVO.setCreator(roleForPlatform1.getPlcreateuser());
		roleVO.setLastModifier(roleForPlatform1.getPlupdateuser());
		roleVO.setLastModifyTime(roleForPlatform1.getPlupdatetime());
		roleVO.setBtmname(FrameWorkBtmTypeConstant.SM_ROLE_BTM_TYPE);
		roleVO.setOwner(roleVO.getCreator());
		roleVO.setTs(roleVO.getLastModifyTime());
		return roleVO;
	}

}