java 递归20210416

package com.orcas.iso.user.service.impl;

import com.orcas.common.enums.OrcasProductType;
import com.orcas.common.enums.ProductStateType;
import com.orcas.common.enums.YesOrNo;
import com.orcas.common.menu.entity.MenuEntity;
import com.orcas.common.menu.entity.MenuTreeTable;
import com.orcas.common.menu.model.MenuRpc;
import com.orcas.common.menu.model.MicroappMenu;
import com.orcas.common.menu.model.ProductMenu;
import com.orcas.common.model.IdNameObject;
import com.orcas.common.product.entity.MicroAppEntity;
import com.orcas.common.product.entity.ProductEntity;
import com.orcas.common.usercenter.entity.RoleEntity;
import com.orcas.common.usercenter.entity.RoleMenuRelationEntity;
import com.orcas.common.usercenter.entity.RoleStaffRelationEntity;
import com.orcas.common.usercenter.entity.StaffEntity;
import com.orcas.common.usercenter.model.*;
import com.orcas.common.util.CommonUtil;
import com.orcas.dictionary.common.convert.DataDictConvert;
import com.orcas.dictionary.common.convert.DataDictConverts;
import com.orcas.iso.config.common.user.CurrentUserHolder;
import com.orcas.iso.menu.dao.MenuMapper;
import com.orcas.iso.menu.service.IMenuService;
import com.orcas.iso.product.dao.MicroAppDao;
import com.orcas.iso.product.dao.ProductDao;
import com.orcas.iso.user.dao.RoleDao;
import com.orcas.iso.user.service.ExternalService;
import com.orcas.iso.user.service.OrgService;
import com.orcas.common.usercenter.constant.DataDictConstant;
import com.orcas.iso.user.service.RoleService;
import com.orcas.iso.user.service.StaffService;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author lqc
 */
@Service
@Transactional
public class RoleServiceImpl implements RoleService {

	@Autowired
	private RoleDao roleDao;
	@Autowired
	private MicroAppDao microAppDao;
	@Autowired
	private StaffService staffService;

	@Autowired
	private ProductDao productDao;

	/**
	 * 新增角色
	 *
	 * @param request 角色请求对象
	 */
	@Override
	public void addRole(RoleRequest request) {
		Assert.hasText(request.getName(), "名称不能为空！");
		Assert.hasText(request.getCode(), "编码不能为空！");
		Assert.hasText(request.getMicroId(), "服务ID不能为空！");
		Assert.hasText(request.getProductId(), "产品id不能为空！");

		// 先判断编码是否存在，校验规则：同一租户同一微服务下，角色编码不重复
		List<RoleEntity> entities = getRoles(request.getMicroId(), request.getCode());
		if (CollectionUtils.isNotEmpty(entities)) {
			throw new RuntimeException(String.format("角色编码[%s]已存在！", request.getCode()));
		}

		RoleEntity entity = new RoleEntity();
		BeanUtils.copyProperties(request, entity);
		entity.setId(CommonUtil.getUuid());
		entity.setCreateTime(LocalDateTime.now());
		entity.setUnitOrganizeId(CurrentUserHolder.get().getUnitOrganizeId());
		roleDao.addRole(entity);
	}

	/**
	 * 获取产品列表
	 *
	 * @param request
	 * @return 产品列表
	 */
	@Override
	public List<Product> getProducts(ProductsOfRoleRequest request) {
		Assert.hasText(request.getUnitOrganizeId(), "组织ID不能为空！");
		// 获取产品列表
//		String unitOrganizeId = request.getUnitOrganizeId();
		List<Product> productList = roleDao.getProducts(request);
		// 获取微服务列表
		if (!CollectionUtils.isEmpty(productList)) {
			for (Product product : productList) {
				List<MicroApp> microappList = roleDao.getMicroappByProductId(product.getId());
				if (!CollectionUtils.isEmpty(microappList)) {
					for (MicroApp microApp : microappList) {
						// 获取角色个数
						Integer roleNum = roleDao.getRoleNumByMicroId(microApp.getId(), product.getId());
						microApp.setRoleNum(roleNum);
						product.setRoleNum(product.getRoleNum() + microApp.getRoleNum());
					}
				}
				product.setMicroAppList(microappList);
			}
		}

		return productList;
	}

	/**
	 * 根据关键字获取角色列表
	 *
	 * @param request 角色列表请求对象
	 * @return 角色实体列表
	 */
	@DataDictConverts({ @DataDictConvert(dictCode = DataDictConstant.ROLE_TYPE, fromProperty = "type") })
	@Override
	public List<RoleEntity> getRolesByKeyword(RolesRequest request) {
		RoleEntity entity = new RoleEntity();
		if (request != null) {
			entity.setUnitOrganizeId(CurrentUserHolder.get().getUnitOrganizeId());
			entity.setMicroId(request.getMicroId());
			entity.setType(request.getRoleType());
			entity.setProductId(request.getProductId());
			entity.setKeyword(request.getKeyword());
		}
		return roleDao.getRolesByKeyword(entity);
	}

	/**
	 * 删除角色列表
	 *
	 * @param ids 角色ID列表
	 */
	@Override
	public void deleteRoles(List<String> ids) {
		Assert.notEmpty(ids, "角色ID列表不能为空！");

		ids.forEach(id -> {
			RoleEntity entity = new RoleEntity();
			entity.setId(id);
			entity.setUpdateTime(LocalDateTime.now());
			entity.setDeleteFlag(YesOrNo.YES.getValue());
			roleDao.updateRole(entity);
		});
	}

	/**
	 * 更新角色
	 *
	 * @param request 角色请求对象
	 */
	@Override
	public void updateRole(RoleRequest request) {
		Assert.hasText(request.getId(), "角色ID不能为空！");
		Assert.hasText(request.getMicroId(), "服务ID不能为空！");

		// 同一租户同一产品下的角色编码不能重复
		if (StringUtils.isNotBlank(request.getCode())) {
			List<RoleEntity> entities = getRoles(request.getMicroId(), request.getCode());
			if (CollectionUtils.isNotEmpty(entities) && !entities.get(0).getId().equals(request.getId())) {
				throw new RuntimeException(String.format("角色编码[%s]已存在！", request.getCode()));
			}
		}

		RoleEntity entity = new RoleEntity();
		BeanUtils.copyProperties(request, entity);
		entity.setUpdateTime(LocalDateTime.now());
		roleDao.updateRole(entity);
	}

	/**
	 * 获取角色
	 *
	 * @param id 角色ID
	 * @return 角色实体
	 */
	@Override
	public RoleEntity getRole(String id) {
		RoleEntity entity = new RoleEntity();
		entity.setId(id);
		List<RoleEntity> entities = roleDao.getRoles(entity);
		return CollectionUtils.isEmpty(entities) ? null : entities.get(0);
	}

	/**
	 * 根据角色ID获取产品名称
	 *
	 * @param roleId 角色ID
	 * @return 产品名称
	 */
	@Override
	public ProductEntity getProductNameByRoleId(String roleId) {
		// 先根据角色ID获取角色
		ProductEntity productEntity = productDao.getProductByRoleId(roleId);
		return productEntity;
	}

	/**
	 * 分配人员列表
	 *
	 * @param request 角色人员列表请求对象
	 */
	@Override
	public void assignStaffs(RoleStaffsRequest request) {
		staffService.addRoleStaffRelations(request.getRoleId(), request.getStaffIds());
	}

	/**
	 * 获取已分配人员列表
	 *
	 * @param roleId 角色ID
	 * @return ID名称对象列表
	 */
	@Override
	public List<IdNameObject> getAssignedStaffs(String roleId) {
		List<StaffEntity> entities = staffService.getStaffsByRoleId(roleId);
		if (CollectionUtils.isEmpty(entities)) {
			return Collections.emptyList();
		}
		return entities.stream().map(entity -> new IdNameObject(entity.getId(), entity.getAccountName()))
				.collect(Collectors.toList());
	}

	/**
	 * 获取机构人员树
	 *
	 * @return 机构人员树节点列表
	 */
	@Override
	public List<InstitutionStaffTreeNode> getInstitutionStaffTree() {
		return staffService.getInstitutionStaffTree();
	}

	@Autowired
	private IMenuService iMenuService;

	/**
	 * 根据角色ID获取已选菜单列表
	 *
	 * @param id 角色ID
	 * @return 已选菜单列表响应对象
	 */
	@Override
	public SelectedMenusResponse getSelectedMenus(String id) {
		RoleEntity entity = getRole(id);
		if (entity == null) {
			return null;
		}
		// 获取菜单树
		SelectedMenusResponse response = new SelectedMenusResponse();
		MenuRpc menuRpc = new MenuRpc();
		menuRpc.setUnitOrganizeId(CurrentUserHolder.get().getUnitOrganizeId());
		menuRpc.setMicroappId(entity.getMicroId());
		List<MenuTreeTable> menuTreeTables = iMenuService.getMenuTree(menuRpc);
		response.setMenuTreeNodes(menuTreeTables);

		// 获取已选菜单列表
		List<IdNameObject> selectedMenus = roleDao.getRoleSelectedMenuByRoleId(id);
		response.setSelectedMenus(selectedMenus);
		return response;
	}

	/**
	 * 保存已选菜单列表 先删除再新增
	 *
	 * @param request 已选菜单列表请求对象
	 */
	@Override
	public void saveSelectedMenus(SelectedMenusRequest request) {
		Assert.hasText(request.getRoleId(), "角色ID不能为空！");
		Assert.notEmpty(request.getMenuIds(), "菜单ID列表不能为空！");

		roleDao.deleteRoleMenuRelationByRoleId(request.getRoleId());

		List<RoleMenuRelationEntity> entities = request.getMenuIds().stream().map(menuId -> {
			RoleMenuRelationEntity entity = new RoleMenuRelationEntity();
			entity.setId(CommonUtil.getUuid());
			entity.setCreateTime(LocalDateTime.now());
			entity.setUnitOrganizeId(CurrentUserHolder.get().getUnitOrganizeId());
			entity.setRoleId(request.getRoleId());
			entity.setMenuId(menuId);
			return entity;
		}).collect(Collectors.toList());
		roleDao.addRoleMenuRelations(entities);
	}

	/**
	 * 根据关键字获取人员列表
	 *
	 * @param keyword 关键字
	 * @return 人员实体列表
	 */
	@Override
	public List<StaffEntity> getStaffsByKeyword(String keyword) {
		StaffsRequest request = new StaffsRequest();
		request.setKeyword(keyword);
		return staffService.getStaffsByKeyword(request);
	}

	public List<RoleEntity> getRolesByMicroappId(String microappId) {
		RoleEntity entity = new RoleEntity();
		entity.setMicroId(microappId);
		return roleDao.getRoles(entity);
	}

	/**
	 * 获取角色列表
	 *
	 * @param microId  产品ID
	 * @param roleCode 角色编码
	 * @return 角色实体列表
	 */
	private List<RoleEntity> getRoles(String microId, String roleCode) {
		RoleEntity entity = new RoleEntity();
		entity.setUnitOrganizeId(CurrentUserHolder.get().getUnitOrganizeId());
		entity.setMicroId(microId);
		entity.setCode(roleCode);
		return roleDao.getRoles(entity);
	}

	@Override
	public List<SelectedRolesResponse> getSelectedRoles(String staffId) {
		// 根据人员ID获取角色列表
		List<RoleEntity> entities = roleDao.getRolesByStaffId(staffId);
		if (CollectionUtils.isEmpty(entities)) {
			return Collections.emptyList();
		}
		// 获取去重后的微应用id数组
		List<String> microIds = entities.stream().map(RoleEntity::getMicroId).distinct().collect(Collectors.toList());
		// 获取去重后的产品id数组
		List<String> productIds = entities.stream().map(RoleEntity::getProductId).distinct()
				.collect(Collectors.toList());
		// 查询微应用名称 所属产品id、名称
		List<SelectedRolesResponse> selectedRolesResponseList = new ArrayList<>();
		if (!CollectionUtils.isEmpty(productIds)) {
			for (String productId : productIds) {
				for (String mircoId : microIds) {
					SelectedRolesResponse response = new SelectedRolesResponse();
					response.setSelectedRoles(new ArrayList<>());
					for (RoleEntity roleEntity : entities) {
						if (roleEntity.getMicroId().equals(mircoId) && roleEntity.getProductId().equals(productId)) {
							response.setProductId(productId);
							response.setMicroId(mircoId);
							response.setProductName(roleEntity.getProductName());
							response.setMicroappName(roleEntity.getMicroName());
							response.getSelectedRoles().add(roleEntity);
						}
					}
					if (!CollectionUtils.isEmpty(response.getSelectedRoles())) {
						selectedRolesResponseList.add(response);
					}
				}
			}
		}
		return selectedRolesResponseList;
	}

	@Override
	public List<RoleEntity> getRoleListByMicroId(String microId, String productId) {
		List<RoleEntity> roleEntityList = roleDao.selectRoleListByMicroId(microId, productId);
		return roleEntityList;
	}

	@Override
	public void saveStaffSelectedRole(SelectedRolesRequest request) {
		// 人员id
		String staffId = request.getStaffId();
		List<String> roleIds = request.getRoleIds();
		// 通过人员id删除原有的关系信息
		roleDao.deleteSRRelationByStaffId(staffId);
		// 插入新的人员角色关系信息
		if (!CollectionUtils.isEmpty(roleIds)) {
			List<RoleStaffRelationEntity> list = new ArrayList<>();
			String unitOrganizeId = CurrentUserHolder.get().getUnitOrganizeId();
			for (String roleId : roleIds) {
				RoleStaffRelationEntity roleStaffRelationEntity = new RoleStaffRelationEntity();
				roleStaffRelationEntity.setId(CommonUtil.getUuid());
				roleStaffRelationEntity.setStaffId(staffId);
				roleStaffRelationEntity.setRoleId(roleId);
				roleStaffRelationEntity.setUnitOrganizeId(unitOrganizeId);
				list.add(roleStaffRelationEntity);
			}
			// 执行批量插入
			roleDao.addSRRelationBatch(list);
		}
	}

	@Autowired
	private MenuMapper menuMapper;

	@Override
	public List<MenuTreeNode> getMenuTree(MenuTreeRequest request) {
//		String productNo = OrcasProductType.orcas.getCode();
		Assert.hasText(request.getProductNo(), "产品编号不能为空！");
		Assert.hasText(request.getMicroNo(), "应用编号不能为空！");
		String unitOrganizeId = request.getUnitOrganizeId();
		String staffId = request.getStaffId();
		String productNo = request.getProductNo();
		String microNo = request.getMicroNo();
		Integer isAdmin = request.getIsAdmin();
		List<MenuEntity> menus = new ArrayList<>();
		// 通过微应用编号获取微应用信息
		MicroAppEntity microAppEntity = microAppDao.getMicroAppInfoByCode(unitOrganizeId, microNo);
		if (microAppEntity == null) {
			return Collections.emptyList();
		}
		// 如果是管理员 则拥有该应用下的所有菜单
		if (isAdmin == 1) {
			menus = menuMapper.getAllMenuList(unitOrganizeId, microAppEntity.getId());
		} else {
			// 通过租户id、产品编号获取产品信息
			ProductEntity productEntity = productDao.getInfoByOrgAndCode(unitOrganizeId, productNo);
			if (productEntity == null) {
				return Collections.emptyList();
			}
			// 通过人员id、产品id、应用id获取已有权限的私有菜单资源
			List<MenuEntity> privateMenuEntities = menuMapper.getPrivateMenu(staffId, productEntity.getId(),
					microAppEntity.getId());
			// 获取该产品、该应用下的公共资源菜单列表
			List<MenuEntity> commonMenuEntities = menuMapper.getCommonMenu(unitOrganizeId, microAppEntity.getId());
			menus.addAll(privateMenuEntities);
			menus.addAll(commonMenuEntities);
			menus.stream().distinct().collect(Collectors.toList()); // 去重
		}

		return buildTopMenuTree(menus);
	}

	private List<MenuTreeNode> buildTopMenuTree(List<MenuEntity> menus) {
		if (CollectionUtils.isEmpty(menus)) {
			return Collections.emptyList();
		}

		List<MenuEntity> topMenuEntities = menus.stream().filter(menu -> StringUtils.isBlank(menu.getMenuParentId()))
				.collect(Collectors.toList());
		if (CollectionUtils.isEmpty(topMenuEntities)) {
			return Collections.emptyList();
		}

		return buildTopMenuTreeNodes(topMenuEntities, menus);
	}

	private List<MenuTreeNode> buildTopMenuTreeNodes(List<MenuEntity> topMenuEntities, List<MenuEntity> menus) {
		return topMenuEntities.stream().map(topMenuEntity -> {
			MenuTreeNode node = new MenuTreeNode();
			node.setMenuId(topMenuEntity.getId());
			node.setMenuName(topMenuEntity.getMenuName());
			node.setMenuCode(topMenuEntity.getMenuCode());
			node.setMenuUrl(topMenuEntity.getMenuUrl());
			node.setMenuType(topMenuEntity.getMenuType());
			node.setMenuLogoUrl(topMenuEntity.getMenuLogo());
			node.setMenuRemark(topMenuEntity.getRemark());
			node.setMenuParentId(topMenuEntity.getMenuParentId());
			node.setRoute(topMenuEntity.getRoute());
			node.setChildren(buildMenuTreeNodes(node, menus));
			return node;
		}).collect(Collectors.toList());
	}

	private List<MenuTreeNode> buildMenuTreeNodes(MenuTreeNode node, List<MenuEntity> menus) {
		List<MenuEntity> subs = menus.stream().filter(menu -> node.getMenuId().equals(menu.getMenuParentId()))
				.collect(Collectors.toList());
		if (CollectionUtils.isEmpty(subs)) {
			return Collections.emptyList();
		}
		return subs.stream().map(sub -> {
			MenuTreeNode treeNode = new MenuTreeNode();
			treeNode.setMenuId(sub.getId());
			treeNode.setMenuName(sub.getMenuName());
			treeNode.setMenuCode(sub.getMenuCode());
			treeNode.setMenuUrl(sub.getMenuUrl());
			treeNode.setMenuType(sub.getMenuType());
			treeNode.setMenuLogoUrl(sub.getMenuLogo());
			treeNode.setMenuRemark(sub.getRemark());
			treeNode.setMenuParentId(sub.getMenuParentId());
			treeNode.setRoute(sub.getRoute());
			treeNode.setChildren(buildMenuTreeNodes(treeNode, menus));
			return treeNode;
		}).collect(Collectors.toList());
	}

	@Override
	public List<MenuTreeNode> getMenuTreeByAccountName(String accountName) {
		Assert.hasText(accountName, "用户账号不能为空！");
		List<MenuEntity> menus = this.iMenuService.selectMenuListByStaffId(accountName);
		if (CollectionUtils.isNotEmpty(menus)) {
			return buildTopMenuTree(menus);
		}
		return buildTopMenuTree(Collections.EMPTY_LIST);
	}
}