package com.tourguide.modules.system.service;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.tourguide.common.api.PageResponse;
|
import com.tourguide.common.exception.BusinessException;
|
import com.tourguide.modules.system.dto.PermissionActionResponse;
|
import com.tourguide.modules.system.dto.PermissionModuleResponse;
|
import com.tourguide.modules.system.dto.PermissionPageResponse;
|
import com.tourguide.modules.system.dto.RoleDetailResponse;
|
import com.tourguide.modules.system.dto.RoleResponse;
|
import com.tourguide.modules.system.dto.RoleSaveRequest;
|
import com.tourguide.modules.system.entity.SystemMenu;
|
import com.tourguide.modules.system.entity.SystemRole;
|
import com.tourguide.modules.system.entity.SystemRoleMenu;
|
import com.tourguide.modules.system.mapper.SystemMenuMapper;
|
import com.tourguide.modules.system.mapper.SystemRoleMapper;
|
import com.tourguide.modules.system.mapper.SystemRoleMenuMapper;
|
import com.tourguide.modules.user.entity.AdminUser;
|
import com.tourguide.modules.user.mapper.AdminUserMapper;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.StringUtils;
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.HashMap;
|
import java.util.HashSet;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
import java.util.UUID;
|
import java.util.stream.Collectors;
|
|
@Service
|
public class SystemRoleService {
|
private final SystemRoleMapper roleMapper;
|
private final SystemMenuMapper menuMapper;
|
private final SystemRoleMenuMapper roleMenuMapper;
|
private final AdminUserMapper adminUserMapper;
|
|
public SystemRoleService(SystemRoleMapper roleMapper, SystemMenuMapper menuMapper,
|
SystemRoleMenuMapper roleMenuMapper, AdminUserMapper adminUserMapper) {
|
this.roleMapper = roleMapper;
|
this.menuMapper = menuMapper;
|
this.roleMenuMapper = roleMenuMapper;
|
this.adminUserMapper = adminUserMapper;
|
}
|
|
public PageResponse<RoleResponse> page(long page, long size, String keyword) {
|
LambdaQueryWrapper<SystemRole> query = new LambdaQueryWrapper<SystemRole>()
|
.like(StringUtils.hasText(keyword), SystemRole::getRoleName,
|
StringUtils.hasText(keyword) ? keyword.trim() : null)
|
.orderByAsc(SystemRole::getId);
|
Page<SystemRole> result = roleMapper.selectPage(new Page<SystemRole>(page, size), query);
|
List<RoleResponse> records = result.getRecords().stream()
|
.map(role -> new RoleResponse(role, countAccounts(role.getRoleCode())))
|
.collect(Collectors.toList());
|
return new PageResponse<RoleResponse>(records, result.getTotal(), result.getCurrent(), result.getSize());
|
}
|
|
public RoleDetailResponse detail(Long id) {
|
SystemRole role = findRole(id);
|
List<Long> relationMenuIds = roleMenuMapper.selectList(new LambdaQueryWrapper<SystemRoleMenu>()
|
.eq(SystemRoleMenu::getRoleId, id))
|
.stream().map(SystemRoleMenu::getMenuId).collect(Collectors.toList());
|
List<Long> menuIds = relationMenuIds.isEmpty() ? Collections.<Long>emptyList()
|
: menuMapper.selectList(new LambdaQueryWrapper<SystemMenu>()
|
.in(SystemMenu::getId, relationMenuIds).eq(SystemMenu::getStatus, 1))
|
.stream().map(SystemMenu::getId).collect(Collectors.toList());
|
return new RoleDetailResponse(role, menuIds);
|
}
|
|
public List<PermissionModuleResponse> permissions() {
|
List<SystemMenu> menus = menuMapper.selectList(new LambdaQueryWrapper<SystemMenu>()
|
.eq(SystemMenu::getStatus, 1).orderByAsc(SystemMenu::getSort, SystemMenu::getId));
|
Map<Long, List<SystemMenu>> children = new HashMap<Long, List<SystemMenu>>();
|
for (SystemMenu menu : menus) {
|
children.computeIfAbsent(menu.getParentId(), key -> new ArrayList<SystemMenu>()).add(menu);
|
}
|
List<PermissionModuleResponse> modules = new ArrayList<PermissionModuleResponse>();
|
for (SystemMenu module : children.getOrDefault(0L, Collections.<SystemMenu>emptyList())) {
|
if (!"DIRECTORY".equals(module.getMenuType())) continue;
|
List<PermissionPageResponse> pages = new ArrayList<PermissionPageResponse>();
|
for (SystemMenu page : children.getOrDefault(module.getId(), Collections.<SystemMenu>emptyList())) {
|
if (!"MENU".equals(page.getMenuType())) continue;
|
List<PermissionActionResponse> actions = children
|
.getOrDefault(page.getId(), Collections.<SystemMenu>emptyList()).stream()
|
.filter(menu -> "BUTTON".equals(menu.getMenuType()))
|
.map(PermissionActionResponse::new).collect(Collectors.toList());
|
pages.add(new PermissionPageResponse(page, actions));
|
}
|
if (!pages.isEmpty()) modules.add(new PermissionModuleResponse(module, pages));
|
}
|
return modules;
|
}
|
|
@Transactional
|
public RoleDetailResponse create(RoleSaveRequest request) {
|
validateRoleName(request.getRoleName(), null);
|
validateMenuIds(request.getMenuIds());
|
SystemRole role = new SystemRole();
|
role.setRoleCode("CUSTOM_" + UUID.randomUUID().toString().replace("-", "").substring(0, 12).toUpperCase());
|
role.setRoleName(request.getRoleName().trim());
|
role.setRemark(normalizeRemark(request.getRemark()));
|
role.setStatus(1);
|
roleMapper.insert(role);
|
replaceRoleMenus(role.getId(), request.getMenuIds());
|
return detail(role.getId());
|
}
|
|
@Transactional
|
public RoleDetailResponse update(Long id, RoleSaveRequest request) {
|
SystemRole role = findRole(id);
|
validateRoleName(request.getRoleName(), id);
|
validateMenuIds(request.getMenuIds());
|
role.setRoleName(request.getRoleName().trim());
|
role.setRemark(normalizeRemark(request.getRemark()));
|
roleMapper.updateById(role);
|
replaceRoleMenus(id, request.getMenuIds());
|
return detail(id);
|
}
|
|
@Transactional
|
public void delete(Long id) {
|
SystemRole role = findRole(id);
|
if ("ADMIN".equals(role.getRoleCode())) {
|
throw new BusinessException(409, "超级管理员角色不能删除");
|
}
|
if (countAccounts(role.getRoleCode()) > 0) {
|
throw new BusinessException(409, "该角色已关联后台账号，不能删除");
|
}
|
roleMenuMapper.markDeletedByRoleId(id);
|
roleMapper.deleteById(id);
|
}
|
|
private SystemRole findRole(Long id) {
|
SystemRole role = roleMapper.selectById(id);
|
if (role == null) throw new BusinessException(404, "角色不存在");
|
return role;
|
}
|
|
private long countAccounts(String roleCode) {
|
return adminUserMapper.selectCount(new LambdaQueryWrapper<AdminUser>().eq(AdminUser::getRoleCode, roleCode));
|
}
|
|
private void validateRoleName(String roleName, Long excludedId) {
|
LambdaQueryWrapper<SystemRole> query = new LambdaQueryWrapper<SystemRole>()
|
.eq(SystemRole::getRoleName, roleName.trim()).ne(excludedId != null, SystemRole::getId, excludedId);
|
if (roleMapper.selectCount(query) > 0) throw new BusinessException(409, "角色名称已存在");
|
}
|
|
private void validateMenuIds(List<Long> menuIds) {
|
Set<Long> uniqueIds = new HashSet<Long>(menuIds);
|
if (uniqueIds.isEmpty()) return;
|
long validCount = menuMapper.selectCount(new LambdaQueryWrapper<SystemMenu>()
|
.in(SystemMenu::getId, uniqueIds).eq(SystemMenu::getStatus, 1));
|
if (validCount != uniqueIds.size()) throw new BusinessException(400, "包含无效权限");
|
}
|
|
private void replaceRoleMenus(Long roleId, List<Long> menuIds) {
|
roleMenuMapper.markDeletedByRoleId(roleId);
|
for (Long menuId : new HashSet<Long>(menuIds)) {
|
SystemRoleMenu relation = new SystemRoleMenu();
|
relation.setRoleId(roleId);
|
relation.setMenuId(menuId);
|
roleMenuMapper.upsert(relation);
|
}
|
}
|
|
private String normalizeRemark(String remark) {
|
return StringUtils.hasText(remark) ? remark.trim() : null;
|
}
|
}
|
