package com.xiaopeng.account.service.impl;
|
|
import cn.hutool.core.bean.BeanUtil;
|
import cn.hutool.core.util.DesensitizedUtil;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.xiaopeng.account.constant.I18nKeyConstant;
|
import com.xiaopeng.account.mapper.SysGroupMapper;
|
import com.xiaopeng.account.model.dto.SysGroupAddDTO;
|
import com.xiaopeng.account.model.dto.SysGroupEditDTO;
|
import com.xiaopeng.account.model.query.GroupUserPageQuery;
|
import com.xiaopeng.account.model.query.SysGroupPageQuery;
|
import com.xiaopeng.account.model.vo.GroupUserVO;
|
import com.xiaopeng.account.model.vo.SysGroupDetailVO;
|
import com.xiaopeng.account.model.vo.SysGroupPageVO;
|
import com.xiaopeng.account.model.vo.SysMenuVO;
|
import com.xiaopeng.account.service.ISysGroupMenuService;
|
import com.xiaopeng.account.service.ISysGroupService;
|
import com.xiaopeng.account.service.ISysRoleService;
|
import com.xiaopeng.api.feignClient.operation.SysMenuClient;
|
import com.xiaopeng.api.model.account.SysGroup;
|
import com.xiaopeng.api.model.account.SysRole;
|
import com.xiaopeng.api.model.account.SysUser;
|
import com.xiaopeng.api.model.operation.SysMenu;
|
import com.xiaopeng.common.core.domain.R;
|
import com.xiaopeng.common.core.exception.ServiceException;
|
import com.xiaopeng.common.core.utils.SensitiveDataCryptoUtil;
|
import com.xiaopeng.common.core.utils.StringUtils;
|
import com.xiaopeng.common.core.web.page.PageInfo;
|
import com.xiaopeng.common.security.service.TokenService;
|
import lombok.RequiredArgsConstructor;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.shardingsphere.transaction.annotation.ShardingSphereTransactionType;
|
import org.apache.shardingsphere.transaction.core.TransactionType;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.context.annotation.Lazy;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.CollectionUtils;
|
|
import javax.annotation.Resource;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* <p>
|
* 权限组设置 服务实现类
|
* </p>
|
*
|
* @author mitao
|
* @since 2026-02-03
|
*/
|
@Slf4j
|
@Service
|
@RequiredArgsConstructor(onConstructor_ = @Lazy)
|
public class SysGroupServiceImpl extends ServiceImpl<SysGroupMapper, SysGroup> implements ISysGroupService {
|
|
private final ISysGroupMenuService groupMenuService;
|
|
@Resource
|
private final SysMenuClient sysMenuClient;
|
private final ISysRoleService sysRoleService;
|
@Resource
|
private TokenService tokenService;
|
|
/**
|
* 新增权限组
|
*
|
* @param dto 新增权限组请求
|
*/
|
@Override
|
@Transactional
|
@ShardingSphereTransactionType(TransactionType.BASE)
|
public void addGroup(SysGroupAddDTO dto) {
|
// 校验组名唯一性
|
if (!checkGroupNameUnique(dto.getGroupName(), null)) {
|
throw new ServiceException("权限组名称已存在", I18nKeyConstant.GROUP_NAME_EXISTS);
|
}
|
|
// 创建权限组实体
|
SysGroup group = BeanUtil.copyProperties(dto, SysGroup.class);
|
// 保存权限组
|
this.save(group);
|
|
// 保存菜单关联
|
groupMenuService.saveGroupMenus(group.getId(), dto.getMenuIds());
|
}
|
|
/**
|
* 编辑权限组
|
*
|
* @param dto 编辑权限组请求
|
*/
|
@Override
|
@Transactional
|
@ShardingSphereTransactionType(TransactionType.BASE)
|
public void editGroup(SysGroupEditDTO dto) {
|
// 校验权限组是否存在
|
SysGroup existGroup = this.getById(dto.getId());
|
if (existGroup == null) {
|
throw new ServiceException("权限组不存在", I18nKeyConstant.GROUP_NOT_EXISTS);
|
}
|
|
// 校验组名唯一性（排除自身）
|
if (!checkGroupNameUnique(dto.getGroupName(), dto.getId())) {
|
throw new ServiceException("权限组名称已存在", I18nKeyConstant.GROUP_NAME_EXISTS);
|
}
|
|
// 更新权限组信息
|
existGroup.setGroupName(dto.getGroupName());
|
existGroup.setRemarks(dto.getRemarks());
|
existGroup.setGroupType(dto.getGroupType());
|
this.updateById(existGroup);
|
|
// 删除旧的菜单关联
|
groupMenuService.deleteByGroupId(dto.getId());
|
|
// 保存新的菜单关联
|
groupMenuService.saveGroupMenus(dto.getId(), dto.getMenuIds());
|
}
|
|
/**
|
* 获取权限组详情（含菜单树）
|
*
|
* @param id 权限组ID
|
* @return 权限组详情
|
*/
|
@Override
|
public SysGroupDetailVO getGroupDetail(Long id) {
|
// 查询权限组基础信息
|
SysGroup group = this.getById(id);
|
if (group == null) {
|
throw new ServiceException("权限组不存在", I18nKeyConstant.GROUP_NOT_EXISTS);
|
}
|
|
SysGroupDetailVO vo = BeanUtil.toBean(group, SysGroupDetailVO.class);
|
|
// 根据权限组ID获取菜单ID列表
|
List<Long> menuIds = groupMenuService.selectMenuIdsByGroupId(id);
|
if (CollectionUtils.isEmpty(menuIds)) {
|
vo.setMenus(new ArrayList<>());
|
return vo;
|
}
|
|
// 通过Feign调用获取菜单详情
|
try {
|
R<List<SysMenu>> result = sysMenuClient.getMenusByMenuIds(menuIds);
|
if (result != null && result.getData() != null) {
|
List<SysMenu> menus = result.getData();
|
// 构建菜单树
|
vo.setMenus(buildMenuTree(menus));
|
vo.setMenuIds(menus.stream().map(SysMenu::getId).collect(Collectors.toList()));
|
} else {
|
vo.setMenus(new ArrayList<>());
|
vo.setMenuIds(new ArrayList<>());
|
}
|
} catch (Exception e) {
|
log.error("获取菜单列表失败: {}", e.getMessage());
|
vo.setMenus(new ArrayList<>());
|
}
|
|
return vo;
|
}
|
|
/**
|
* 权限组分页列表
|
*
|
* @param query 分页查询参数
|
* @return 分页结果
|
*/
|
@Override
|
public PageInfo<SysGroupPageVO> pageList(SysGroupPageQuery query) {
|
// 构建查询条件
|
LambdaQueryWrapper<SysGroup> wrapper = new LambdaQueryWrapper<>();
|
if (StringUtils.isNotBlank(query.getGroupName())) {
|
wrapper.like(SysGroup::getGroupName, query.getGroupName());
|
}
|
wrapper.orderByDesc(SysGroup::getCreateTime);
|
|
// 分页查询
|
PageInfo<SysGroup> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
|
PageInfo<SysGroup> groupPage = this.page(pageInfo, wrapper);
|
|
// 转换为VO
|
PageInfo<SysGroupPageVO> resultPage = new PageInfo<>(query.getPageNum(), query.getPageSize());
|
resultPage.setTotal(groupPage.getTotal());
|
|
List<SysGroupPageVO> voList = groupPage.getRecords().stream().map(group -> {
|
SysGroupPageVO vo = BeanUtil.copyProperties(group, SysGroupPageVO.class);
|
// 统计绑定用户数
|
Long bindCount = baseMapper.countBindUsers(group.getId());
|
vo.setBindCount(bindCount != null ? bindCount : 0L);
|
return vo;
|
}).collect(Collectors.toList());
|
|
resultPage.setRecords(voList);
|
return resultPage;
|
}
|
|
/**
|
* 查询权限组绑定用户分页列表
|
*
|
* @param query 分页查询参数
|
* @return 分页结果
|
*/
|
@Override
|
public PageInfo<GroupUserVO> queryUserPageList(GroupUserPageQuery query) {
|
// 校验权限组是否存在
|
SysGroup group = this.getById(query.getGroupId());
|
if (group == null) {
|
throw new ServiceException("权限组不存在");
|
}
|
|
// 分页查询
|
PageInfo<GroupUserVO> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
|
query.setGroupType(group.getGroupType());
|
query.setPhoneNumberQueryValues(SensitiveDataCryptoUtil.queryValues(query.getPhoneNumber()));
|
Page<GroupUserVO> records = baseMapper.queryUserPageList(pageInfo, query);
|
records.getRecords().forEach(record -> {
|
record.setPhoneNumber(SensitiveDataCryptoUtil.decryptIfPossible(record.getPhoneNumber()));
|
record.setUserAccount(SensitiveDataCryptoUtil.decryptIfPossible(record.getUserAccount()));
|
});
|
pageInfo.setRecords(records.getRecords());
|
// 手动设置分页信息（因为使用了自定义SQL）
|
return pageInfo;
|
}
|
|
/**
|
* 校验权限组名称唯一性
|
*
|
* @param groupName 权限组名称
|
* @param excludeId 排除的权限组ID（编辑时使用）
|
* @return true=唯一，false=不唯一
|
*/
|
@Override
|
public boolean checkGroupNameUnique(String groupName, Long excludeId) {
|
LambdaQueryWrapper<SysGroup> wrapper = new LambdaQueryWrapper<>();
|
wrapper.eq(SysGroup::getGroupName, groupName);
|
if (excludeId != null) {
|
wrapper.ne(SysGroup::getId, excludeId);
|
}
|
return this.count(wrapper) == 0;
|
}
|
|
/**
|
* 构建菜单树
|
*
|
* @param menus 菜单列表
|
* @return 菜单树
|
*/
|
private List<SysMenuVO> buildMenuTree(List<SysMenu> menus) {
|
if (CollectionUtils.isEmpty(menus)) {
|
return new ArrayList<>();
|
}
|
|
Map<Long, SysMenuVO> menuMap = new HashMap<>();
|
List<SysMenuVO> rootMenus = new ArrayList<>();
|
|
// 转换为VO并建立映射
|
for (SysMenu menu : menus) {
|
SysMenuVO vo = convertToMenuVO(menu);
|
vo.setChildren(new ArrayList<>());
|
menuMap.put(vo.getId(), vo);
|
}
|
|
// 构建树结构
|
for (SysMenuVO vo : menuMap.values()) {
|
if (vo.getParentId() == null || vo.getParentId() == 0) {
|
rootMenus.add(vo);
|
} else {
|
SysMenuVO parent = menuMap.get(vo.getParentId());
|
if (parent != null) {
|
parent.getChildren().add(vo);
|
} else {
|
// 父节点不在列表中，作为根节点处理
|
rootMenus.add(vo);
|
}
|
}
|
}
|
|
// 按orderNum排序
|
sortMenuTree(rootMenus);
|
|
return rootMenus;
|
}
|
|
/**
|
* 转换为菜单VO
|
*
|
* @param menu 菜单实体
|
* @return 菜单VO
|
*/
|
private SysMenuVO convertToMenuVO(SysMenu menu) {
|
SysMenuVO vo = new SysMenuVO();
|
BeanUtils.copyProperties(menu, vo);
|
return vo;
|
}
|
|
/**
|
* 递归排序菜单树
|
*
|
* @param menus 菜单列表
|
*/
|
private void sortMenuTree(List<SysMenuVO> menus) {
|
if (CollectionUtils.isEmpty(menus)) {
|
return;
|
}
|
menus.sort(Comparator.comparing(SysMenuVO::getOrderNum, Comparator.nullsLast(Comparator.naturalOrder())));
|
for (SysMenuVO menu : menus) {
|
if (!CollectionUtils.isEmpty(menu.getChildren())) {
|
sortMenuTree(menu.getChildren());
|
}
|
}
|
}
|
|
/**
|
* 删除权限组
|
* @param id
|
*/
|
@Override
|
public void deleteById(Long id) {
|
Long count = sysRoleService.lambdaQuery().eq(SysRole::getGroupId, id).count();
|
if (count > 0) {
|
throw new ServiceException("删除失败，该权限组已关联角色", I18nKeyConstant.SYS_GROUP_DELETE_FAIL);
|
}
|
removeById(id);
|
}
|
|
/**
|
* 获取手机号脱敏
|
* @param phoneNumber
|
* @return
|
*/
|
@Override
|
public String getPhoneDesensitization(String phoneNumber){
|
boolean b = getPhoneDesensitization();
|
if(b){
|
return DesensitizedUtil.mobilePhone(phoneNumber);
|
}
|
return phoneNumber;
|
}
|
|
/**
|
* 获取登录用户的权限组，获取权限组的手机号是否脱敏的字段
|
* true 需要脱敏，false 否
|
* @return
|
*/
|
@Override
|
public boolean getPhoneDesensitization(){
|
try {
|
SysUser sysUser = tokenService.getLoginUser().getSysUser();
|
//用户查询角色 角色查询 权限组
|
int count = baseMapper.getPhoneDesensitization(sysUser.getId());
|
return count > 0;
|
} catch (Exception e) {
|
return false;
|
}
|
}
|
|
|
|
|
}
|
