package com.nanjing.water.service;
|
|
import com.nanjing.water.common.ConstantFactory;
|
import com.nanjing.water.common.ExecutedResult;
|
import com.nanjing.water.common.PagerResult;
|
import com.nanjing.water.common.jwt.JWTUtil;
|
import com.nanjing.water.common.jwt.LoginUserDTO;
|
import com.nanjing.water.common.model.Tuple;
|
import com.nanjing.water.common.security.MD5Util;
|
import com.nanjing.water.common.util.*;
|
import com.nanjing.water.entity.enums.EState;
|
import com.nanjing.water.entity.enums.EUserType;
|
import com.nanjing.water.entity.request.ReqChangePassword;
|
import com.nanjing.water.entity.request.adminuser.ReqAdminLogin;
|
import com.nanjing.water.entity.request.adminuser.ReqCreateAdminUser;
|
import com.nanjing.water.entity.request.adminuser.ReqModifyAdminUser;
|
import com.nanjing.water.entity.request.adminuser.ReqSetListRole4Admin;
|
import com.nanjing.water.entity.response.admin.ResAdminLogin;
|
import com.nanjing.water.entity.response.admin.ResAdminMenuTreeAndPermission;
|
import com.nanjing.water.entity.response.admin.ResAdminPower;
|
import com.nanjing.water.entity.search.SearchAdminUser;
|
import com.nanjing.water.repository.impl.*;
|
import com.nanjing.water.repository.po.*;
|
import com.nanjing.water.repository.vo.AdminRoleVO;
|
import com.nanjing.water.repository.vo.AdminUserVO;
|
import com.nanjing.water.service.cache.AdminMenuService;
|
import com.nanjing.water.service.cache.AdminPermissionService;
|
import com.nanjing.water.service.convert.AdminMenuConvert;
|
import com.nanjing.water.service.convert.AdminPermissionConvert;
|
import com.nanjing.water.service.convert.AdminRoleConvert;
|
import com.nanjing.water.service.convert.AdminUserConvert;
|
import com.nanjing.water.service.dto.ResAdminDetail;
|
import com.wf.captcha.SpecCaptcha;
|
import org.apache.commons.lang3.BooleanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.data.redis.core.StringRedisTemplate;
|
import org.springframework.stereotype.Service;
|
|
import java.util.*;
|
import java.util.concurrent.TimeUnit;
|
import java.util.stream.Collectors;
|
|
@Service
|
public class AdminService extends BaseService {
|
private static final List<Integer> LIST_ADMIN_TYPE = Arrays.asList(
|
EUserType.ADMIN.getValue(),
|
EUserType.ADMIN_USER.getValue()
|
);
|
|
@Autowired
|
private AdminUserMapperImpl dao;
|
@Autowired
|
private AdminMenuMapperImpl menusDao;
|
@Autowired
|
private AdminPermissionMapperImpl permissionDao;
|
@Autowired
|
private AdminRoleMapperImpl roleDao;
|
@Autowired
|
private AdminRoleMenuRelationMapperImpl roleMenuRelationDao;
|
@Autowired
|
private AdminRolePermissionRelationMapperImpl rolePermissionRelationDao;
|
@Autowired
|
private AdminRoleRelationMapperImpl adminRoleRelationDao;
|
|
@Autowired
|
private AdminMenuService menusService;
|
@Autowired
|
private AdminPermissionService permissionService;
|
@Autowired
|
private AdminPowerService adminPowerService;
|
@Autowired
|
private StringRedisTemplate redisTemplate;
|
|
|
// 添加后台管理员
|
public ExecutedResult<Long> createAdmin(ReqCreateAdminUser request) {
|
AdminUserPO find = dao.get4Name(request.getUserName());
|
if (Objects.nonNull(find)) {
|
return ExecutedResult.failed("管理员帐号已存在。" + request.getUserName());
|
}
|
AdminUserPO item = AdminUserConvert.INSTANCE.toCreate(request);
|
item.setUserRelId(0L);
|
item.setNickName(ParameterUtil.dealNullStr(request.getNickName()));
|
item.setHeadImg(ParameterUtil.dealNullStr(request.getHeadImg()));
|
item.setEmail(ParameterUtil.dealNullStr(request.getEmail()));
|
item.setContact(ParameterUtil.dealNullStr(request.getContact()));
|
// 密码加密
|
item.setPassword(MD5Util.encrypt(request.getPassword() + ConstantFactory.KEY_PASSWORD));
|
item.setStatus(EState.NORMAL.getValue());
|
item.setCreateTime(LocalDateTimeUtil.nowTimeStamp());
|
int rowCount = dao.insert(item);
|
if (rowCount == 1) {
|
return ExecutedResult.success(item.getId());
|
}
|
return ExecutedResult.failed("添加[管理员]失败。");
|
}
|
|
// 修改后台管理员
|
public ExecutedResult<String> modify(ReqModifyAdminUser request) {
|
ExecutedResult<AdminUserPO> check = this.check4Id(request.getId());
|
if (check.isFailed()) {
|
return ExecutedResult.failed(check.getMsg(), check.getMsgCode());
|
}
|
|
AdminUserPO item = new AdminUserPO();
|
item.setId(request.getId());
|
item.setNickName(ParameterUtil.dealNullStr(request.getNickName()));
|
item.setHeadImg(ParameterUtil.dealNullStr(request.getHeadImg()));
|
item.setContact(ParameterUtil.dealNullStr(request.getContact()));
|
item.setEmail(ParameterUtil.dealNullStr(request.getEmail()));
|
item.setStatus(request.getStatus());
|
int rowCount = dao.updateById(item);
|
if (rowCount == 1) {
|
return ExecutedResult.success();
|
}
|
return ExecutedResult.failed("编辑[管理员]失败。");
|
}
|
|
// 获取指定管理员详情
|
public ExecutedResult<ResAdminDetail> detail(Long adminId) {
|
ExecutedResult<AdminUserPO> check = this.check4Id(adminId);
|
if (check.isFailed()) {
|
return ExecutedResult.failed(check.getMsg(), check.getMsgCode());
|
}
|
ResAdminDetail result = AdminUserConvert.INSTANCE.toDetail(check.getData());
|
|
result.setListRole(new ArrayList<>());
|
//找到角色已有的菜单列表
|
List<AdminRoleRelationPO> listRoleRel = adminRoleRelationDao.list4Admin(adminId);
|
if (ListUtil.isNotNullOrEmpty(listRoleRel)) {
|
List<Long> listRoleId = listRoleRel.stream()
|
.map(AdminRoleRelationPO::getRoleId)
|
.collect(Collectors.toList());
|
List<AdminRolePO> listRole = roleDao.getList(listRoleId);
|
result.setListRole(AdminRoleConvert.INSTANCE.toVo(listRole));
|
}
|
return ExecutedResult.success(result);
|
}
|
|
// 管理员登录
|
public ExecutedResult<ResAdminLogin> adminLogin(ReqAdminLogin request) throws Exception {
|
Integer maxNumber = 3;
|
AdminUserPO user = dao.get4Name(request.getUserName());
|
//获取缓存中的验证码
|
String realCode = redisTemplate.opsForValue().get(request.getUuid());
|
if (realCode == null) {
|
return ExecutedResult.failed("验证码已失效，请重新获取~");
|
}
|
// 验证码校验
|
if (!request.getCode().equalsIgnoreCase(realCode)) {
|
return ExecutedResult.failed("验证码错误");
|
}
|
//获取缓存中设备码
|
String machineCode = redisTemplate.opsForValue().get(request.getMachineCode());
|
if (StringUtil.isNotNullOrEmpty(machineCode) && Integer.valueOf(machineCode) >= maxNumber) {
|
return ExecutedResult.failed("登录次数限制，请10分钟后重新登录！");
|
}
|
if (checkPassword(user, request.getPassword())) {
|
// 构建登录用户
|
LoginUserDTO loginUser = new LoginUserDTO();
|
loginUser.setUserId(user.getId().toString());
|
loginUser.setUserType(user.getUserType());
|
loginUser.setNickName(user.getNickName());
|
loginUser.setPhone(user.getContact());
|
// 保存用户信息到jwt
|
String token = JWTUtil.getToken(loginUser);
|
ResAdminLogin result = this.getListPower4Admin(user);
|
result.setName(user.getNickName());
|
result.setToken(token);
|
return ExecutedResult.success(result);
|
} else {
|
Integer newAttempts = StringUtil.isNullOrEmpty(machineCode) ? 1 : Integer.valueOf(machineCode) + 1;
|
redisTemplate.opsForValue().set(request.getMachineCode(), newAttempts.toString());
|
redisTemplate.expire(request.getMachineCode(), 10, TimeUnit.MINUTES);
|
}
|
|
|
return ExecutedResult.failed("账号或密码错误!");
|
}
|
|
private static boolean checkPassword(AdminUserPO user, String passWord) throws Exception {
|
if (Objects.isNull(user)) {
|
return false;
|
}
|
if (BooleanUtils.isFalse(Objects.equals(user.getStatus(), EState.NORMAL.getValue()))) {
|
return false;
|
}
|
if (BooleanUtils.isFalse(MD5Util.encrypt(passWord + ConstantFactory.KEY_PASSWORD).equals(user.getPassword()))) {
|
return false;
|
}
|
return true;
|
}
|
|
/**
|
* 生成验证码图片并返回其 Base64 编码字符串
|
*
|
* @param uuid 用于标识验证码的唯一标识符
|
* @return 包含验证码图片 Base64 编码的响应结果
|
*/
|
public ExecutedResult<String> generate(String uuid) {
|
SpecCaptcha specCaptcha = new SpecCaptcha(100, 30, 4);
|
// captcha.setCharType(Captcha.TYPE_DEFAULT);
|
String code = specCaptcha.text().toLowerCase();
|
// 缓存验证码
|
redisTemplate.opsForValue().set(uuid, code);
|
// 设置验证码3分钟后过期
|
redisTemplate.expire(uuid, 3, TimeUnit.MINUTES);
|
return ExecutedResult.success(specCaptcha.toBase64());
|
}
|
|
// 获取管理员权限列表
|
public ExecutedResult<ResAdminPower> getPower(Long adminId) {
|
ResAdminPower result = new ResAdminPower();
|
result.setMenus(new ArrayList<>());
|
|
ExecutedResult<AdminUserPO> check = this.check4Id(adminId);
|
if (check.isFailed()) {
|
return ExecutedResult.success(result);
|
}
|
AdminUserPO user = check.getData();
|
|
List<AdminMenuPO> listMenu;
|
List<AdminPermissionPO> listPermission = null;
|
// 超级管理员有所有权限
|
if (Objects.equals(user.getUserType(), EUserType.ADMIN.getValue())) {
|
listMenu = menusService.listAllWithCache();
|
listPermission = permissionService.listAllWithCache();
|
} else {
|
//找到角色已有的菜单列表
|
List<AdminRoleRelationPO> listRole = adminRoleRelationDao.list4Admin(adminId);
|
if (ListUtil.isNullOrEmpty(listRole)) {
|
return ExecutedResult.success(result);
|
}
|
List<Long> listRoleId = listRole.stream()
|
.map(AdminRoleRelationPO::getRoleId)
|
.collect(Collectors.toList());
|
|
listMenu = menusService.listUserAllWithCache(adminId, listRoleId, adminPowerService::getListMenu4Role);
|
listPermission = permissionService.listUserAllWithCache(adminId, listRoleId, adminPowerService::getListPermission4Role);
|
}
|
if (ListUtil.isNotNullOrEmpty(listMenu)) {
|
// 筛选状态
|
listMenu = listMenu.stream()
|
.filter(c -> Objects.equals(c.getStatus(), EState.NORMAL.getValue()))
|
.collect(Collectors.toList());
|
result.setMenus(AdminMenuConvert.INSTANCE.toVo(listMenu));
|
}
|
if (ListUtil.isNotNullOrEmpty(listPermission)) {
|
// 筛选状态
|
listPermission = listPermission.stream()
|
.filter(c -> Objects.equals(c.getStatus(), EState.NORMAL.getValue()))
|
.collect(Collectors.toList());
|
result.setPermissions(AdminPermissionConvert.INSTANCE.toDetail(listPermission));
|
}
|
return ExecutedResult.success(result);
|
}
|
|
// 修改密码
|
public ExecutedResult<String> changePassword(LoginUserDTO user, ReqChangePassword request) {
|
Long adminId = NumericUtil.tryParseLong(user.getUserId(), 0L);
|
ExecutedResult<AdminUserPO> check = this.check4Id(adminId);
|
if (check.isFailed()) {
|
return ExecutedResult.failed(check.getMsg(), check.getMsgCode());
|
}
|
String oldPass = MD5Util.encrypt(request.getOldPassword() + ConstantFactory.KEY_PASSWORD);
|
if (BooleanUtils.isFalse(oldPass.equals(check.getData().getPassword()))) {
|
return ExecutedResult.failed("密码校验失败。");
|
}
|
return this.changePasswordDo(adminId, request.getNewPassword());
|
}
|
|
private ExecutedResult<String> changePasswordDo(Long adminId, String password) {
|
AdminUserPO item = new AdminUserPO();
|
item.setId(adminId);
|
// 密码加密
|
item.setPassword(MD5Util.encrypt(password + ConstantFactory.KEY_PASSWORD));
|
int rowCount = dao.updateById(item);
|
if (rowCount == 1) {
|
return ExecutedResult.success();
|
}
|
return ExecutedResult.failed("密码修改失败。");
|
}
|
|
// 重置密码
|
public ExecutedResult<String> resetPassword(Long adminId) {
|
ExecutedResult<AdminUserPO> check = this.check4Id(adminId);
|
if (check.isFailed()) {
|
return ExecutedResult.failed(check.getMsg(), check.getMsgCode());
|
}
|
String pass = RandVerifyCode.complexCode(8);
|
ExecutedResult<String> changePasswordDo = this.changePasswordDo(adminId, pass);
|
if (changePasswordDo.isFailed()) {
|
return changePasswordDo;
|
}
|
return ExecutedResult.success(pass);
|
}
|
|
// 分页查询所有管理员
|
public ExecutedResult<PagerResult<AdminUserVO>> search(SearchAdminUser request) {
|
List<AdminUserVO> result = new ArrayList<>();
|
|
super.dealPager(request);
|
request.setLastRowNo((request.getPage() - 1) * NumericUtil.tryParseLong(request.getLimit()));
|
// 处理时间范围
|
Tuple<String, String> createTimeRange = ParameterUtil.getTimeRange(request.getCreateTimeRange());
|
if (StringUtil.isNotNullOrEmpty(createTimeRange.getItem1())) {
|
request.setCreateTimeStart(LocalDateTimeUtil.getTimeStamp(createTimeRange.getItem1()).getTime());
|
}
|
if (StringUtil.isNotNullOrEmpty(createTimeRange.getItem2())) {
|
request.setCreateTimeEnd(LocalDateTimeUtil.getTimeStamp(createTimeRange.getItem2()).getTime());
|
}
|
|
PagerResult<AdminUserPO> pagerResult = dao.search(request);
|
|
if (NumericUtil.tryParseLong(pagerResult.getTotal()).compareTo(0L) < 1) {
|
return ExecutedResult.success(
|
new PagerResult<>(request.getLimit(), request.getPage(), 0L, new ArrayList<>())
|
);
|
}
|
List<AdminUserPO> list = pagerResult.getList();
|
Long lastId = 0L;
|
if (ListUtil.isNotNullOrEmpty(list)) {
|
lastId = list.stream().map(AdminUserPO::getId).min(Comparator.comparing(c -> c)).get();
|
|
list.forEach(item -> {
|
AdminUserVO vo = AdminUserConvert.INSTANCE.toVo(item);
|
result.add(vo);
|
});
|
}
|
PagerResult<AdminUserVO> view = new PagerResult<>(request.getLimit(), request.getPage(), pagerResult.getTotal(), result);
|
view.setLastId(lastId);
|
return ExecutedResult.success(view);
|
}
|
|
public ExecutedResult<String> stop(Long id) {
|
// 验证记录是否存在
|
ExecutedResult<AdminUserPO> checkExists = this.check4Id(id);
|
if (checkExists.isFailed()) {
|
return ExecutedResult.failed(checkExists.getMsg());
|
}
|
AdminUserPO item = new AdminUserPO();
|
item.setId(id);
|
item.setStatus(EState.DISABLED.getValue());
|
|
int rowCount = this.dao.updateById(item);
|
if (rowCount == 1) {
|
return ExecutedResult.success();
|
}
|
return ExecutedResult.failed("停用[管理员]失败。");
|
}
|
|
public ExecutedResult<String> enable(Long id) {
|
// 验证记录是否存在
|
ExecutedResult<AdminUserPO> checkExists = this.check4Id(id);
|
if (checkExists.isFailed()) {
|
return ExecutedResult.failed(checkExists.getMsg());
|
}
|
AdminUserPO item = new AdminUserPO();
|
item.setId(id);
|
item.setStatus(EState.NORMAL.getValue());
|
|
int rowCount = this.dao.updateById(item);
|
if (rowCount == 1) {
|
return ExecutedResult.success();
|
}
|
return ExecutedResult.failed("启用[管理员]失败。");
|
}
|
|
public ExecutedResult<String> remove(Long adminId) {
|
ExecutedResult<AdminUserPO> check = this.check4Id(adminId);
|
if (check.isFailed()) {
|
return ExecutedResult.failed(check.getMsg(), check.getMsgCode());
|
}
|
Boolean remove = dao.remove(adminId);
|
if (remove) {
|
return ExecutedResult.success();
|
}
|
return ExecutedResult.failed("删除[管理员]失败");
|
}
|
|
public ExecutedResult<AdminUserPO> check4Id(Long id) {
|
AdminUserPO item = dao.get(id);
|
if (Objects.isNull(item)) {
|
return ExecutedResult.failed("[管理员]不存在: " + id);
|
}
|
return ExecutedResult.success(item);
|
}
|
|
// 设置管理员的角色列表
|
public ExecutedResult<String> setListRole4Admin(ReqSetListRole4Admin request) {
|
Long adminId = request.getId();
|
ExecutedResult<AdminUserPO> checkExists = this.check4Id(adminId);
|
if (checkExists.isFailed()) {
|
return ExecutedResult.failed(checkExists.getMsg());
|
}
|
AdminUserPO find = checkExists.getData();
|
//找到管理员已有的角色列表
|
List<AdminRoleRelationPO> listOld = adminRoleRelationDao.list4Admin(adminId);
|
listOld = ParameterUtil.dealNull(listOld);
|
|
//现在设置的角色id列表
|
List<Long> listRoleId = ParameterUtil.dealNull(request.getListRole());
|
|
//批量新增
|
if (BooleanUtils.isFalse(listRoleId.isEmpty())) {
|
List<AdminRoleRelationPO> list = listRoleId.stream()
|
.map(c -> {
|
AdminRoleRelationPO item = new AdminRoleRelationPO();
|
item.setAdminId(adminId);
|
item.setRoleId(c);
|
item.setCreateTime(LocalDateTimeUtil.nowTimeStamp());
|
return item;
|
}).collect(Collectors.toList());
|
Boolean addList = adminRoleRelationDao.addList(list);
|
if (BooleanUtils.isFalse(addList)) {
|
return ExecutedResult.failed("给管理员“" + adminId + "”新增角色失败。" + listRoleId);
|
}
|
}
|
//批量删除
|
if (BooleanUtils.isFalse(listOld.isEmpty())) {
|
List<Long> listId = listOld.stream()
|
.map(AdminRoleRelationPO::getId).collect(Collectors.toList());
|
Boolean removeList = adminRoleRelationDao.remove(listId);
|
if (BooleanUtils.isFalse(removeList)) {
|
return ExecutedResult.failed("删除管理员“" + adminId + "”已有角色失败。" + listId);
|
}
|
}
|
// 删除指定用户的菜单和权限缓存
|
adminPowerService.removePower4User(adminId);
|
return ExecutedResult.success();
|
}
|
|
// 获取管理员的角色列表
|
public ExecutedResult<List<AdminRoleVO>> getListRole4Admin(Long id) {
|
List<AdminRoleVO> result = new ArrayList<>();
|
|
ExecutedResult<AdminUserPO> checkExists = this.check4Id(id);
|
if (checkExists.isFailed()) {
|
return ExecutedResult.failed(checkExists.getMsg());
|
}
|
AdminUserPO find = checkExists.getData();
|
List<AdminRolePO> list;
|
if (Objects.equals(find.getUserType(), EUserType.ADMIN.getValue())) {
|
list = roleDao.getList();
|
} else {
|
//找到角色已有的菜单列表
|
List<AdminRoleRelationPO> listRole = adminRoleRelationDao.list4Admin(id);
|
listRole = ParameterUtil.dealNull(listRole);
|
if (ListUtil.isNullOrEmpty(listRole)) {
|
return ExecutedResult.success(result);
|
}
|
List<Long> listRoleId = listRole.stream()
|
.map(AdminRoleRelationPO::getRoleId)
|
.collect(Collectors.toList());
|
list = roleDao.getList(listRoleId);
|
}
|
if (ListUtil.isNotNullOrEmpty(list)) {
|
// 筛选状态
|
list = list.stream()
|
.filter(c -> Objects.equals(c.getStatus(), EState.NORMAL.getValue()))
|
.collect(Collectors.toList());
|
result = AdminRoleConvert.INSTANCE.toVo(list);
|
}
|
return ExecutedResult.success(result);
|
}
|
|
/**
|
* 获取指定用户的菜单和权限
|
*
|
* @param user 用户
|
*/
|
public ResAdminLogin getListPower4Admin(AdminUserPO user) {
|
Long adminId = user.getId();
|
|
ResAdminLogin result = new ResAdminLogin();
|
result.setId(user.getId());
|
result.setUserType(user.getUserType());
|
result.setMenus(new ArrayList<>());
|
|
List<AdminMenuPO> listMenu;
|
List<AdminPermissionPO> listPermission = null;
|
|
// 管理员从缓存中取有所有权限（普通管理员剔除系统管理部分菜单）
|
if (LIST_ADMIN_TYPE.contains(user.getUserType())) {
|
listMenu = menusService.listAllWithCache();
|
|
if (Objects.equals(EUserType.ADMIN_USER.getValue(), user.getUserType())) {
|
List<Long> listNot = Arrays.asList(10101L, 10102L, 10103L);
|
listMenu = listMenu.stream().filter(c -> !listNot.contains(c.getId())).collect(Collectors.toList());
|
}
|
|
listPermission = permissionService.listAllWithCache();
|
} else {
|
//找到角色已有的菜单列表
|
List<AdminRoleRelationPO> listRole = adminRoleRelationDao.list4Admin(adminId);
|
if (ListUtil.isNullOrEmpty(listRole)) {
|
return result;
|
}
|
List<Long> listRoleId = listRole.stream()
|
.map(AdminRoleRelationPO::getRoleId)
|
.collect(Collectors.toList());
|
|
listMenu = menusService.listUserAllWithCache(user.getId(), listRoleId, adminPowerService::getListMenu4Role);
|
listPermission = permissionService.listUserAllWithCache(user.getId(), listRoleId, adminPowerService::getListPermission4Role);
|
}
|
if (ListUtil.isNotNullOrEmpty(listMenu)) {
|
// 筛选状态
|
listMenu = listMenu.stream()
|
.filter(c -> Objects.equals(c.getStatus(), EState.NORMAL.getValue()))
|
.collect(Collectors.toList());
|
Map<Long, List<AdminPermissionPO>> mapPermission = new HashMap<>();
|
// 筛选权限状态
|
if (ListUtil.isNotNullOrEmpty(listPermission)) {
|
// 筛选状态
|
mapPermission = listPermission.stream()
|
.filter(c -> Objects.equals(c.getStatus(), EState.NORMAL.getValue()))
|
.collect(Collectors.groupingBy(AdminPermissionPO::getMenuId));
|
}
|
|
List<AdminMenuPO> listRoot = listMenu.stream().filter(c -> Objects.equals(c.getLevel(), 1)).collect(Collectors.toList());
|
listRoot = listRoot.stream()
|
.sorted(Comparator.comparing(AdminMenuPO::getSort).reversed())
|
.collect(Collectors.toList());
|
if (ListUtil.isNotNullOrEmpty(listRoot)) {
|
for (AdminMenuPO item : listRoot) {
|
ResAdminMenuTreeAndPermission view = AdminMenuConvert.INSTANCE.toTreeVo(item);
|
adminPowerService.fillChildMenu(view, listMenu, mapPermission);
|
adminPowerService.fillPermission4Menu(view, mapPermission);
|
result.getMenus().add(view);
|
}
|
}
|
}
|
if (ListUtil.isNotNullOrEmpty(listPermission)) {
|
// 筛选状态
|
List<String> listPermissionSn = listPermission.stream()
|
.filter(c -> Objects.equals(c.getStatus(), EState.NORMAL.getValue()))
|
.sorted(Comparator.comparing(AdminPermissionPO::getMenuId))
|
.map(AdminPermissionPO::getSn)
|
.collect(Collectors.toList());
|
result.setListPermission(listPermissionSn);
|
}
|
return result;
|
}
|
}
|
