package com.tcm.training.admin.user.service;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.tcm.training.admin.common.PageResponse;
|
import com.tcm.training.admin.user.dto.RoleSaveRequest;
|
import com.tcm.training.admin.user.entity.SysMenu;
|
import com.tcm.training.admin.user.entity.SysRole;
|
import com.tcm.training.admin.user.entity.SysRoleMenu;
|
import com.tcm.training.admin.user.mapper.SysMenuMapper;
|
import com.tcm.training.admin.user.mapper.SysRoleMapper;
|
import com.tcm.training.admin.user.mapper.SysRoleMenuMapper;
|
import com.tcm.training.admin.user.row.RoleDetailRow;
|
import com.tcm.training.admin.user.row.RoleListRow;
|
import com.tcm.training.admin.user.vo.PermissionTreeNodeVO;
|
import com.tcm.training.admin.user.vo.RoleDetailVO;
|
import com.tcm.training.admin.user.vo.RoleListItemVO;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.time.LocalDateTime;
|
import java.util.ArrayList;
|
import java.util.LinkedHashMap;
|
import java.util.LinkedHashSet;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
import java.util.UUID;
|
|
@Service
|
public class RoleAppService {
|
|
private static final String SUPER_ADMIN_CODE = "SUPER_ADMIN";
|
|
private final SysRoleMapper sysRoleMapper;
|
private final SysMenuMapper sysMenuMapper;
|
private final SysRoleMenuMapper sysRoleMenuMapper;
|
|
public RoleAppService(
|
SysRoleMapper sysRoleMapper,
|
SysMenuMapper sysMenuMapper,
|
SysRoleMenuMapper sysRoleMenuMapper
|
) {
|
this.sysRoleMapper = sysRoleMapper;
|
this.sysMenuMapper = sysMenuMapper;
|
this.sysRoleMenuMapper = sysRoleMenuMapper;
|
}
|
|
public PageResponse<RoleListItemVO> page(int page, int pageSize, String roleName) {
|
IPage<RoleListRow> records = sysRoleMapper.selectRolePage(new Page<RoleListRow>(page, pageSize), roleName);
|
List<RoleListItemVO> list = new ArrayList<RoleListItemVO>();
|
for (RoleListRow row : records.getRecords()) {
|
RoleListItemVO item = new RoleListItemVO();
|
item.setId(row.getId());
|
item.setRoleName(row.getRoleName());
|
item.setAccountCount(row.getAccountCount() == null ? 0L : row.getAccountCount());
|
item.setCreatedAt(row.getCreatedAt());
|
item.setRemark(row.getRemark());
|
list.add(item);
|
}
|
return PageResponse.of(list, records.getTotal(), records.getCurrent(), records.getSize());
|
}
|
|
public RoleDetailVO detail(Long id) {
|
RoleDetailRow row = sysRoleMapper.selectRoleDetail(id);
|
if (row == null) {
|
throw new IllegalArgumentException("角色不存在");
|
}
|
RoleDetailVO vo = new RoleDetailVO();
|
vo.setId(row.getId());
|
vo.setRoleName(row.getRoleName());
|
vo.setRemark(row.getRemark());
|
vo.setAccountCount(row.getAccountCount() == null ? 0L : row.getAccountCount());
|
vo.setCreatedAt(row.getCreatedAt());
|
vo.setUpdatedAt(row.getUpdatedAt());
|
vo.setPermissionIds(sysRoleMapper.selectPermissionIdsByRoleId(id));
|
return vo;
|
}
|
|
public List<PermissionTreeNodeVO> permissionTree() {
|
List<SysMenu> menus = sysMenuMapper.selectList(new LambdaQueryWrapper<SysMenu>()
|
.eq(SysMenu::getDeleted, 0)
|
.eq(SysMenu::getStatus, 1)
|
.orderByAsc(SysMenu::getSort, SysMenu::getId));
|
Map<Long, PermissionTreeNodeVO> nodeMap = new LinkedHashMap<Long, PermissionTreeNodeVO>();
|
List<PermissionTreeNodeVO> roots = new ArrayList<PermissionTreeNodeVO>();
|
for (SysMenu menu : menus) {
|
PermissionTreeNodeVO node = new PermissionTreeNodeVO();
|
node.setId(menu.getId());
|
node.setParentId(menu.getParentId());
|
node.setName(menu.getName());
|
node.setType(menu.getType());
|
node.setPermissionKey(menu.getPermissionKey());
|
nodeMap.put(node.getId(), node);
|
}
|
for (SysMenu menu : menus) {
|
PermissionTreeNodeVO node = nodeMap.get(menu.getId());
|
PermissionTreeNodeVO parent = nodeMap.get(menu.getParentId());
|
if (parent == null || menu.getParentId() == null || menu.getParentId() == 0L) {
|
roots.add(node);
|
} else {
|
parent.getChildren().add(node);
|
}
|
}
|
return roots;
|
}
|
|
@Transactional
|
public RoleDetailVO create(RoleSaveRequest req) {
|
String roleName = req.getRoleName().trim();
|
ensureRoleNameUnique(roleName, null);
|
List<Long> permissionIds = normalizePermissionIds(req.getPermissionIds());
|
validatePermissionIds(permissionIds);
|
|
SysRole role = new SysRole();
|
role.setRoleName(roleName);
|
role.setRoleCode(generateRoleCode());
|
role.setRemark(normalizeRemark(req.getRemark()));
|
role.setStatus(1);
|
role.setDeleted(0);
|
role.setCreatedAt(LocalDateTime.now());
|
role.setUpdatedAt(LocalDateTime.now());
|
sysRoleMapper.insert(role);
|
|
saveRoleMenus(role.getId(), permissionIds);
|
return detail(role.getId());
|
}
|
|
@Transactional
|
public RoleDetailVO update(Long id, RoleSaveRequest req) {
|
SysRole role = requireRole(id);
|
String roleName = req.getRoleName().trim();
|
ensureRoleNameUnique(roleName, id);
|
List<Long> permissionIds = normalizePermissionIds(req.getPermissionIds());
|
validatePermissionIds(permissionIds);
|
|
role.setRoleName(roleName);
|
role.setRemark(normalizeRemark(req.getRemark()));
|
role.setUpdatedAt(LocalDateTime.now());
|
sysRoleMapper.updateById(role);
|
|
saveRoleMenus(id, permissionIds);
|
return detail(id);
|
}
|
|
@Transactional
|
public void delete(Long id) {
|
SysRole role = requireRole(id);
|
if (SUPER_ADMIN_CODE.equals(role.getRoleCode())) {
|
throw new IllegalArgumentException("超级管理员角色不允许删除");
|
}
|
long bindCount = sysRoleMapper.countAccountBindingsByRoleId(id);
|
if (bindCount > 0) {
|
throw new IllegalArgumentException("该角色已关联帐号，暂不允许删除");
|
}
|
|
role.setStatus(0);
|
role.setUpdatedAt(LocalDateTime.now());
|
sysRoleMapper.updateById(role);
|
sysRoleMapper.deleteById(id);
|
sysRoleMenuMapper.delete(new LambdaQueryWrapper<SysRoleMenu>()
|
.eq(SysRoleMenu::getRoleId, id));
|
}
|
|
private SysRole requireRole(Long id) {
|
SysRole role = sysRoleMapper.selectOne(new LambdaQueryWrapper<SysRole>()
|
.eq(SysRole::getId, id)
|
.eq(SysRole::getDeleted, 0)
|
.last("limit 1"));
|
if (role == null) {
|
throw new IllegalArgumentException("角色不存在");
|
}
|
return role;
|
}
|
|
private void ensureRoleNameUnique(String roleName, Long excludeId) {
|
LambdaQueryWrapper<SysRole> wrapper = new LambdaQueryWrapper<SysRole>()
|
.eq(SysRole::getRoleName, roleName)
|
.eq(SysRole::getDeleted, 0);
|
if (excludeId != null) {
|
wrapper.ne(SysRole::getId, excludeId);
|
}
|
SysRole exists = sysRoleMapper.selectOne(wrapper.last("limit 1"));
|
if (exists != null) {
|
throw new IllegalArgumentException("角色名称已存在");
|
}
|
}
|
|
private List<Long> normalizePermissionIds(List<Long> permissionIds) {
|
Set<Long> idSet = new LinkedHashSet<Long>();
|
if (permissionIds != null) {
|
for (Long permissionId : permissionIds) {
|
if (permissionId != null) {
|
idSet.add(permissionId);
|
}
|
}
|
}
|
return new ArrayList<Long>(idSet);
|
}
|
|
private void validatePermissionIds(List<Long> permissionIds) {
|
if (permissionIds.isEmpty()) {
|
throw new IllegalArgumentException("操作权限不能为空");
|
}
|
List<SysMenu> menus = sysMenuMapper.selectList(new LambdaQueryWrapper<SysMenu>()
|
.in(SysMenu::getId, permissionIds)
|
.eq(SysMenu::getDeleted, 0)
|
.eq(SysMenu::getStatus, 1));
|
if (menus.size() != permissionIds.size()) {
|
throw new IllegalArgumentException("存在无效的操作权限");
|
}
|
}
|
|
private void saveRoleMenus(Long roleId, List<Long> permissionIds) {
|
sysRoleMenuMapper.delete(new LambdaQueryWrapper<SysRoleMenu>()
|
.eq(SysRoleMenu::getRoleId, roleId));
|
LocalDateTime now = LocalDateTime.now();
|
for (Long permissionId : permissionIds) {
|
SysRoleMenu relation = new SysRoleMenu();
|
relation.setRoleId(roleId);
|
relation.setMenuId(permissionId);
|
relation.setCreatedAt(now);
|
sysRoleMenuMapper.insert(relation);
|
}
|
}
|
|
private String normalizeRemark(String remark) {
|
if (remark == null) {
|
return null;
|
}
|
String trimmed = remark.trim();
|
return trimmed.isEmpty() ? null : trimmed;
|
}
|
|
private String generateRoleCode() {
|
for (int i = 0; i < 10; i++) {
|
String code = "ROLE_" + UUID.randomUUID().toString().replace("-", "")
|
.substring(0, 12).toUpperCase();
|
SysRole exists = sysRoleMapper.selectOne(new LambdaQueryWrapper<SysRole>()
|
.eq(SysRole::getRoleCode, code)
|
.last("limit 1"));
|
if (exists == null) {
|
return code;
|
}
|
}
|
throw new IllegalStateException("角色编码生成失败");
|
}
|
}
|
