package com.nanjing.water.service;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.nanjing.water.common.ExecutedResult;
|
import com.nanjing.water.common.PagerResult;
|
import com.nanjing.water.common.model.Tuple;
|
import com.nanjing.water.common.util.*;
|
import com.nanjing.water.entity.enums.EState;
|
import com.nanjing.water.entity.request.ReqListSetSort;
|
import com.nanjing.water.entity.request.ReqSetSort;
|
import com.nanjing.water.entity.request.adminmenu.ReqCreateAdminMenu;
|
import com.nanjing.water.entity.request.adminmenu.ReqModifyAdminMenu;
|
import com.nanjing.water.entity.request.adminpermission.ReqCreateAdminPermission;
|
import com.nanjing.water.entity.request.adminpermission.ReqModifyAdminPermission;
|
import com.nanjing.water.entity.request.adminrole.ReqCreateAdminRole;
|
import com.nanjing.water.entity.request.adminrole.ReqModifyAdminRole;
|
import com.nanjing.water.entity.request.adminrolemenurelation.ReqSetListMenu4Role;
|
import com.nanjing.water.entity.response.admin.ResAdminMenuTreeAndPermission;
|
import com.nanjing.water.entity.response.admin.ResAdminPermission;
|
import com.nanjing.water.entity.response.admin.ResAdminPower;
|
import com.nanjing.water.entity.search.SearchAdminMenu;
|
import com.nanjing.water.entity.search.SearchAdminPermission;
|
import com.nanjing.water.entity.search.SearchAdminRole;
|
import com.nanjing.water.repository.impl.*;
|
import com.nanjing.water.repository.po.*;
|
import com.nanjing.water.repository.vo.AdminMenuVO;
|
import com.nanjing.water.repository.vo.AdminRoleVO;
|
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 org.apache.commons.lang3.BooleanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
@Service
|
public class AdminPowerService extends BaseService {
|
@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;
|
|
|
|
// 创建菜单
|
public ExecutedResult<Long> createMenu(ReqCreateAdminMenu request) {
|
AdminMenuPO item = AdminMenuConvert.INSTANCE.toCreate(request);
|
item.setParentId(NumericUtil.tryParseLong(request.getParentId(), 0L));
|
item.setTitle(ParameterUtil.dealNullStr(request.getTitle()));
|
item.setLevel(1);
|
item.setSort(NumericUtil.tryParseInt(request.getSort(), 0));
|
item.setStatus(EState.NORMAL.getValue());
|
item.setCreateTime(LocalDateTimeUtil.nowTimeStamp());
|
if (item.getParentId().compareTo(0L) > 0) {
|
ExecutedResult<AdminMenuPO> check = this.checkMenuId(request.getParentId());
|
if (check.isFailed()) {
|
return ExecutedResult.failed("父级菜单不存在: " + request.getParentId());
|
}
|
item.setLevel(check.getData().getLevel() + 1);
|
}
|
int rowCount = menusDao.insert(item);
|
if (rowCount == 1) {
|
// 删除菜单缓存
|
menusService.removeListAllCache();
|
// 删除所有权限缓存
|
permissionService.removeListAllCache();
|
// 删除所有用户的菜单和权限缓存
|
this.removePowerAllUser();
|
|
// 给新增的菜单添加默认权限
|
permissionService.createDefaultPermission(item);
|
return ExecutedResult.success(item.getId());
|
}
|
return ExecutedResult.failed("创建[菜单]失败。");
|
}
|
private ExecutedResult<AdminMenuPO> checkMenuId(Long id) {
|
AdminMenuPO item = menusDao.get(id);
|
if (Objects.isNull(item)) {
|
return ExecutedResult.failed("[菜单]不存在: " + id);
|
}
|
return ExecutedResult.success(item);
|
}
|
protected ExecutedResult<List<AdminMenuPO>> checkMenuId(List<Long> listId) {
|
// 从数据库查找测试信息
|
List<AdminMenuPO> list = menusDao.getList(listId);
|
if (ListUtil.isNullOrEmpty(list)) {
|
return ExecutedResult.failed("[菜单]不存在." + listId);
|
}
|
// 数据库找到的id列表
|
List<Long> listIdFind = list.stream().map(AdminMenuPO::getId).collect(Collectors.toList());
|
// 数量不一致
|
if (listId.size() != listIdFind.size()) {
|
// 筛选数据库不存在的测试信息
|
List<Long> listIdNotFound = listId.stream().filter(c -> !listIdFind.contains(c)).collect(Collectors.toList());
|
if (ListUtil.isNullOrEmpty(list)) {
|
return ExecutedResult.failed("[菜单]不存在." + listIdNotFound);
|
}
|
}
|
return ExecutedResult.success(list);
|
}
|
|
// 编辑菜单
|
public ExecutedResult<String> modifyMenu(ReqModifyAdminMenu request) {
|
ExecutedResult<AdminMenuPO> checkExists = this.checkMenuId(request.getId());
|
if (checkExists.isFailed()) {
|
return ExecutedResult.failed(checkExists.getMsg());
|
}
|
AdminMenuPO item = AdminMenuConvert.INSTANCE.toModify(request);
|
item.setTitle(ParameterUtil.dealNullStr(request.getTitle()));
|
item.setParentId(NumericUtil.tryParseLong(request.getParentId(), 0L));
|
item.setLevel(1);
|
item.setSort(NumericUtil.tryParseInt(request.getSort(), 0));
|
if (item.getParentId().compareTo(0L) > 0) {
|
ExecutedResult<AdminMenuPO> check = this.checkMenuId(request.getParentId());
|
if (check.isFailed()) {
|
return ExecutedResult.failed("父级菜单不存在: " + request.getParentId());
|
}
|
item.setLevel(check.getData().getLevel() + 1);
|
}
|
int rowCount = menusDao.updateById(item);
|
if (rowCount == 1) {
|
// 删除菜单缓存
|
menusService.removeListAllCache();
|
// 删除所有权限缓存
|
permissionService.removeListAllCache();
|
// 删除所有用户的菜单和权限缓存
|
this.removePowerAllUser();
|
return ExecutedResult.success();
|
}
|
return ExecutedResult.failed("编辑[菜单]失败。");
|
}
|
|
public ExecutedResult<String> removeMenu(Long id) {
|
// 验证记录是否存在
|
ExecutedResult<AdminMenuPO> checkExists = this.checkMenuId(id);
|
if (checkExists.isFailed()) {
|
return ExecutedResult.failed(checkExists.getMsg());
|
}
|
|
Boolean result = menusDao.deleteLogic(id);
|
if (result) {
|
// 删除菜单缓存
|
menusService.removeListAllCache();
|
// 删除所有权限缓存
|
permissionService.removeListAllCache();
|
// 删除所有用户的菜单和权限缓存
|
this.removePowerAllUser();
|
return ExecutedResult.success();
|
}
|
return ExecutedResult.failed("删除[菜单]失败。");
|
}
|
|
public ExecutedResult<String> removeMenuList(List<Long> listId) {
|
// 验证记录是否存在
|
ExecutedResult<List<AdminMenuPO>> checkExists = this.checkMenuId(listId);
|
if (checkExists.isFailed()) {
|
return ExecutedResult.failed(checkExists.getMsg());
|
}
|
|
Boolean result = menusDao.deleteLogic(listId);
|
if (result) {
|
// 删除菜单缓存
|
menusService.removeListAllCache();
|
// 删除所有权限缓存
|
permissionService.removeListAllCache();
|
// 删除所有用户的菜单和权限缓存
|
this.removePowerAllUser();
|
return ExecutedResult.success();
|
}
|
return ExecutedResult.failed("删除[菜单]失败。");
|
}
|
|
// 变更菜单状态
|
public ExecutedResult<String> changeMenuStatus(Long id, EState status) {
|
ExecutedResult<AdminMenuPO> checkExists = this.checkMenuId(id);
|
if (checkExists.isFailed()) {
|
return ExecutedResult.failed(checkExists.getMsg());
|
}
|
AdminMenuPO upd = new AdminMenuPO();
|
upd.setId(id);
|
upd.setStatus(status.getValue());
|
int rowCount = menusDao.updateById(upd);
|
if (rowCount == 1) {
|
// 删除菜单缓存
|
menusService.removeListAllCache();
|
// 删除所有权限缓存
|
permissionService.removeListAllCache();
|
// 删除所有用户的菜单和权限缓存
|
this.removePowerAllUser();
|
return ExecutedResult.success();
|
}
|
return ExecutedResult.failed("修改[菜单]状态失败。");
|
}
|
|
// 获取所有层级菜单
|
public ExecutedResult<List<ResAdminMenuTreeAndPermission>> getListTreeMenu() {
|
List<ResAdminMenuTreeAndPermission> result = new ArrayList<>();
|
LambdaQueryWrapper<AdminMenuPO> where = menusDao.query();
|
where.in(AdminMenuPO::getStatus, Arrays.asList(
|
EState.NORMAL.getValue()
|
));
|
List<AdminMenuPO> list = menusDao.selectList(where);
|
|
if (ListUtil.isNullOrEmpty(list)) {
|
return ExecutedResult.success(result);
|
}
|
List<AdminMenuPO> listRoot = list.stream().filter(c -> Objects.equals(c.getLevel(), 1)).collect(Collectors.toList());
|
listRoot = listRoot.stream()
|
.sorted(Comparator.comparing(AdminMenuPO::getSort))
|
.collect(Collectors.toList());
|
if (ListUtil.isNullOrEmpty(listRoot)) {
|
return ExecutedResult.success(result);
|
}
|
|
List<Long> listMenuId = list.stream()
|
.map(AdminMenuPO::getId)
|
.collect(Collectors.toList());
|
List<AdminPermissionPO> listPermission = permissionDao.list4MenuId(listMenuId);
|
Map<Long, List<AdminPermissionPO>> mapPermission = listPermission.stream()
|
.collect(Collectors.groupingBy(AdminPermissionPO::getMenuId));
|
|
for (AdminMenuPO item : listRoot) {
|
ResAdminMenuTreeAndPermission view = AdminMenuConvert.INSTANCE.toTreeVo(item);
|
this.fillChildMenu(view, list, mapPermission);
|
this.fillPermission4Menu(view, mapPermission);
|
result.add(view);
|
}
|
return ExecutedResult.success(result);
|
}
|
public void fillPermission4Menu(ResAdminMenuTreeAndPermission view, Map<Long, List<AdminPermissionPO>> mapPermission) {
|
view.setPermissions(new ArrayList<>());
|
if (BooleanUtils.isFalse(mapPermission.containsKey(view.getId()))) {
|
return;
|
}
|
List<AdminPermissionPO> list = mapPermission.get(view.getId());
|
view.setPermissions(AdminPermissionConvert.INSTANCE.toDetail(list));
|
}
|
public void fillChildMenu(ResAdminMenuTreeAndPermission view, List<AdminMenuPO> list, Map<Long, List<AdminPermissionPO>> mapPermission) {
|
List<AdminMenuPO> listChild = list.stream()
|
.filter(c -> c.getParentId().equals(view.getId()))
|
.collect(Collectors.toList());
|
view.setChildren(new ArrayList<>());
|
if (ListUtil.isNullOrEmpty(listChild)) {
|
return;
|
}
|
listChild = listChild.stream()
|
.sorted(Comparator.comparing(AdminMenuPO::getSort).reversed())
|
.collect(Collectors.toList());
|
for (AdminMenuPO child : listChild) {
|
ResAdminMenuTreeAndPermission viewChild = AdminMenuConvert.INSTANCE.toTreeVo(child);
|
this.fillChildMenu(viewChild, list, mapPermission);
|
this.fillPermission4Menu(viewChild, mapPermission);
|
view.getChildren().add(viewChild);
|
}
|
}
|
|
// 获取指定菜单的子级菜单
|
public ExecutedResult<List<AdminMenuVO>> getListChildMenu(Long parentId) {
|
List<AdminMenuPO> list = menusDao.list4Parent(parentId);
|
if (ListUtil.isNullOrEmpty(list)) {
|
return ExecutedResult.success(new ArrayList<>());
|
}
|
return ExecutedResult.success(AdminMenuConvert.INSTANCE.toVo(list));
|
}
|
|
// 分页查询菜单
|
public ExecutedResult<PagerResult<AdminMenuVO>> searchMenu(SearchAdminMenu request) {
|
List<AdminMenuVO> 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());
|
}
|
if (NumericUtil.tryParseInt(request.getStatus(), 0).compareTo(0) < 1 && ListUtil.isNullOrEmpty(request.getListStatus())) {
|
request.setListStatus(Arrays.asList(EState.NORMAL.getValue(), EState.DISABLED.getValue()));
|
}
|
|
PagerResult<AdminMenuPO> pagerResult = menusDao.search(request);
|
|
if (NumericUtil.tryParseLong(pagerResult.getTotal()).compareTo(0L) < 1) {
|
return ExecutedResult.success(
|
new PagerResult<>(request.getLimit(), request.getPage(), 0L, new ArrayList<>())
|
);
|
}
|
List<AdminMenuPO> list = pagerResult.getList();
|
Long lastId = 0L;
|
if (ListUtil.isNotNullOrEmpty(list)) {
|
lastId = list.stream().map(AdminMenuPO::getId).min(Comparator.comparing(c -> c)).get();
|
result = AdminMenuConvert.INSTANCE.toVo(list);
|
}
|
PagerResult<AdminMenuVO> view = new PagerResult<>(request.getLimit(), request.getPage(), pagerResult.getTotal(), result);
|
view.setLastId(lastId);
|
return ExecutedResult.success(view);
|
}
|
|
// 创建权限
|
public ExecutedResult<Long> createPermission(ReqCreateAdminPermission request) {
|
String sn = request.getSn();
|
AdminPermissionPO find = permissionDao.get4Sn(sn);
|
if (Objects.nonNull(find) && find.getId().compareTo(0L) > 0) {
|
return ExecutedResult.failed("权限编码已存在。" + sn);
|
}
|
ExecutedResult<AdminMenuPO> checkExists = this.checkMenuId(request.getMenuId());
|
if (checkExists.isFailed()) {
|
return ExecutedResult.failed(checkExists.getMsg());
|
}
|
|
AdminPermissionPO item = new AdminPermissionPO();
|
item.setName(request.getName());
|
item.setSn(request.getSn());
|
item.setMenuId(request.getMenuId());
|
item.setMenuId(request.getMenuId());
|
item.setStatus(EState.NORMAL.getValue());
|
item.setMenuUrl(ParameterUtil.dealNullStr(request.getMenuUrl()));
|
item.setIcon(ParameterUtil.dealNullStr(request.getIcon()));
|
item.setType(ParameterUtil.dealNullStr(request.getType()));
|
item.setCreateTime(LocalDateTimeUtil.nowTimeStamp());
|
int rowCount = permissionDao.insert(item);
|
if (rowCount == 1) {
|
// 删除权限缓存
|
permissionService.removeListAllCache();
|
return ExecutedResult.success(item.getId());
|
}
|
return ExecutedResult.failed("创建[权限]失败。");
|
}
|
|
// 编辑权限
|
public ExecutedResult<String> modifyPermission(ReqModifyAdminPermission request) {
|
Long id = request.getId();
|
String sn = request.getSn();
|
ExecutedResult<AdminPermissionPO> checkExists = this.checkPermissionId(id);
|
if (checkExists.isFailed()) {
|
return ExecutedResult.failed(checkExists.getMsg());
|
}
|
AdminPermissionPO findBySn = permissionDao.get4Sn(sn);
|
if (Objects.nonNull(findBySn) && !Objects.equals(id, findBySn.getId())) {
|
return ExecutedResult.failed("权限编码已存在。" + sn);
|
}
|
ExecutedResult<AdminMenuPO> check = this.checkMenuId(request.getMenuId());
|
if (check.isFailed()) {
|
return ExecutedResult.failed(check.getMsg());
|
}
|
|
AdminPermissionPO item = new AdminPermissionPO();
|
item.setId(id);
|
item.setSn(request.getSn());
|
item.setMenuId(request.getMenuId());
|
item.setName(request.getName());
|
int rowCount = permissionDao.updateById(item);
|
if (rowCount == 1) {
|
// 删除权限缓存
|
permissionService.removeListAllCache();
|
return ExecutedResult.success();
|
}
|
return ExecutedResult.failed("编辑[权限]失败。");
|
}
|
private ExecutedResult<AdminPermissionPO> checkPermissionId(Long id) {
|
AdminPermissionPO item = permissionDao.get(id);
|
if (Objects.isNull(item)) {
|
return ExecutedResult.failed("[权限]不存在: " + id);
|
}
|
return ExecutedResult.success(item);
|
}
|
|
// 删除权限
|
public ExecutedResult<String> removePermission(Long id) {
|
AdminPermissionPO find = permissionDao.get(id);
|
if (null == find) {
|
return ExecutedResult.failed("[权限]记录未找到。" + id);
|
}
|
Boolean remove = permissionDao.remove(id);
|
if (remove) {
|
// 删除权限缓存
|
permissionService.removeListAllCache();
|
return ExecutedResult.success();
|
}
|
return ExecutedResult.failed("删除[权限]失败");
|
}
|
|
// 分页查询权限
|
public ExecutedResult<PagerResult<ResAdminPermission>> searchPermission(SearchAdminPermission request) {
|
List<ResAdminPermission> 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());
|
}
|
if (NumericUtil.tryParseInt(request.getStatus(), 0).compareTo(0) < 1 && ListUtil.isNullOrEmpty(request.getListStatus())) {
|
request.setListStatus(Arrays.asList(EState.NORMAL.getValue(), EState.DISABLED.getValue()));
|
}
|
PagerResult<AdminPermissionPO> pagerResult = permissionDao.search(request);
|
|
if (NumericUtil.tryParseLong(pagerResult.getTotal()).compareTo(0L) < 1) {
|
return ExecutedResult.success(
|
new PagerResult<>(request.getLimit(), request.getPage(), 0L, new ArrayList<>())
|
);
|
}
|
List<AdminPermissionPO> list = pagerResult.getList();
|
Long lastId = 0L;
|
if (ListUtil.isNotNullOrEmpty(list)) {
|
lastId = list.stream().map(AdminPermissionPO::getId).min(Comparator.comparing(c -> c)).get();
|
result = AdminPermissionConvert.INSTANCE.toDetail(list);
|
}
|
PagerResult<ResAdminPermission> view = new PagerResult<>(request.getLimit(), request.getPage(), pagerResult.getTotal(), result);
|
view.setLastId(lastId);
|
return ExecutedResult.success(view);
|
}
|
|
// 创建角色
|
public ExecutedResult<Long> createRole(ReqCreateAdminRole request) {
|
AdminRolePO item = AdminRoleConvert.INSTANCE.toCreate(request);
|
item.setDescription(ParameterUtil.dealNullStr(request.getDescription()));
|
item.setStatus(EState.NORMAL.getValue());
|
item.setSort(NumericUtil.tryParseInt(request.getSort(), 0));
|
item.setCreateTime(LocalDateTimeUtil.nowTimeStamp());
|
int rowCount = roleDao.insert(item);
|
if (rowCount == 1) {
|
return ExecutedResult.success(item.getId());
|
}
|
return ExecutedResult.failed("创建[角色]失败。");
|
}
|
|
// 编辑角色
|
public ExecutedResult<String> modifyRole(ReqModifyAdminRole request) {
|
ExecutedResult<AdminRolePO> checkExists = this.checkRoleId(request.getId());
|
if (checkExists.isFailed()) {
|
return ExecutedResult.failed(checkExists.getMsg());
|
}
|
AdminRolePO item = AdminRoleConvert.INSTANCE.toModify(request);
|
item.setSort(NumericUtil.tryParseInt(request.getSort(), 0));
|
item.setDescription(ParameterUtil.dealNullStr(request.getDescription()));
|
int rowCount = roleDao.updateById(item);
|
if (rowCount == 1) {
|
return ExecutedResult.success();
|
}
|
return ExecutedResult.failed("编辑[角色]失败。");
|
}
|
|
// 修改角色状态
|
public ExecutedResult<String> changeRoleStatus(Long id, EState status) {
|
ExecutedResult<AdminRolePO> checkExists = this.checkRoleId(id);
|
if (checkExists.isFailed()) {
|
return ExecutedResult.failed(checkExists.getMsg());
|
}
|
AdminRolePO upd = new AdminRolePO();
|
upd.setId(id);
|
upd.setStatus(status.getValue());
|
int rowCount = roleDao.updateById(upd);
|
if (rowCount == 1) {
|
return ExecutedResult.success();
|
}
|
return ExecutedResult.failed("修改[角色]状态失败。");
|
}
|
private ExecutedResult<AdminRolePO> checkRoleId(Long id) {
|
AdminRolePO item = roleDao.selectById(id);
|
if (Objects.isNull(item)) {
|
return ExecutedResult.failed("[角色]不存在: " + id);
|
}
|
return ExecutedResult.success(item);
|
}
|
private ExecutedResult<List<AdminRolePO>> checkRoleId(List<Long> listId) {
|
// 从数据库查找测试信息
|
List<AdminRolePO> list = roleDao.getList(listId);
|
if (ListUtil.isNullOrEmpty(list)) {
|
return ExecutedResult.failed("[角色]不存在." + listId);
|
}
|
// 数据库找到的id列表
|
List<Long> listIdFind = list.stream().map(AdminRolePO::getId).collect(Collectors.toList());
|
// 数量不一致
|
if (listId.size() != listIdFind.size()) {
|
// 筛选数据库不存在的测试信息
|
List<Long> listIdNotFound = listId.stream().filter(c -> !listIdFind.contains(c)).collect(Collectors.toList());
|
if (ListUtil.isNullOrEmpty(list)) {
|
return ExecutedResult.failed("[角色]不存在." + listIdNotFound);
|
}
|
}
|
return ExecutedResult.success(list);
|
}
|
|
public ExecutedResult<String> removeRole(Long id) {
|
// 验证记录是否存在
|
ExecutedResult<AdminRolePO> checkExists = this.checkRoleId(id);
|
if (checkExists.isFailed()) {
|
return ExecutedResult.failed(checkExists.getMsg());
|
}
|
|
Boolean result = roleDao.deleteLogic(id);
|
if (BooleanUtils.isFalse(result)) {
|
return ExecutedResult.failed("删除[角色]失败。");
|
}
|
return ExecutedResult.success();
|
}
|
|
public ExecutedResult<String> removeRoleList(List<Long> listId) {
|
// 验证记录是否存在
|
ExecutedResult<List<AdminRolePO>> checkExists = this.checkRoleId(listId);
|
if (checkExists.isFailed()) {
|
return ExecutedResult.failed(checkExists.getMsg());
|
}
|
|
Boolean result = roleDao.deleteLogic(listId);
|
if (BooleanUtils.isFalse(result)) {
|
return ExecutedResult.failed("删除[角色]失败。");
|
}
|
return ExecutedResult.success();
|
}
|
|
// 分页查询角色
|
public ExecutedResult<PagerResult<AdminRoleVO>> searchRole(SearchAdminRole request) {
|
List<AdminRoleVO> 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());
|
}
|
if (NumericUtil.tryParseInt(request.getStatus(), 0).compareTo(0) < 1 && ListUtil.isNullOrEmpty(request.getListStatus())) {
|
request.setListStatus(Arrays.asList(EState.NORMAL.getValue(), EState.DISABLED.getValue()));
|
}
|
|
PagerResult<AdminRolePO> pagerResult = roleDao.search(request);
|
|
if (NumericUtil.tryParseLong(pagerResult.getTotal()).compareTo(0L) < 1) {
|
return ExecutedResult.success(
|
new PagerResult<>(request.getLimit(), request.getPage(), 0L, new ArrayList<>())
|
);
|
}
|
List<AdminRolePO> list = pagerResult.getList();
|
Long lastId = 0L;
|
if (ListUtil.isNotNullOrEmpty(list)) {
|
lastId = list.stream().map(AdminRolePO::getId).min(Comparator.comparing(c -> c)).get();
|
result = AdminRoleConvert.INSTANCE.toVo(list);
|
}
|
PagerResult<AdminRoleVO> view = new PagerResult<>(request.getLimit(), request.getPage(), pagerResult.getTotal(), result);
|
view.setLastId(lastId);
|
return ExecutedResult.success(view);
|
}
|
|
// 设置角色菜单权限列表
|
public ExecutedResult<String> setListMenu4Role(ReqSetListMenu4Role request) {
|
Long roleId = request.getId();
|
ExecutedResult<AdminRolePO> checkExists = this.checkRoleId(roleId);
|
if (checkExists.isFailed()) {
|
return ExecutedResult.failed(checkExists.getMsg());
|
}
|
AdminRolePO find = checkExists.getData();
|
Long now = LocalDateTimeUtil.nowTimeStamp();
|
|
//找到角色已有的菜单列表
|
List<AdminRoleMenuRelationPO> listOld = roleMenuRelationDao.list4Role(roleId);
|
listOld = ParameterUtil.dealNull(listOld);
|
List<Long> listOldMenuId = listOld.stream()
|
.map(AdminRoleMenuRelationPO::getMenuId)
|
.collect(Collectors.toList());
|
|
//现在设置的菜单id列表
|
List<Long> listMenuId = ParameterUtil.dealNull(request.getListMenu());
|
|
//找到所有菜单
|
List<Long> listAllId = new ArrayList<>(listOldMenuId);
|
listAllId.addAll(listMenuId);
|
ListUtil.repeat(listAllId);
|
List<AdminMenuPO> listMenu = menusDao.getList(listAllId);
|
Map<Long, AdminMenuPO> mapMenu = listMenu.stream()
|
.collect(Collectors.toMap(AdminMenuPO::getId, c -> c));
|
|
//找到新增菜单列表(新菜单列表的元素，不存在于已有的菜单列表中)
|
List<Long> listNew = listMenuId.stream()
|
.filter(c -> !listOldMenuId.contains(c))
|
.collect(Collectors.toList());
|
//找到删除菜单列表(已有菜单列表的元素，不存在于新菜单列表)
|
List<Long> listRemove = listOldMenuId.stream()
|
.filter(c -> !listMenuId.contains(c))
|
.collect(Collectors.toList());
|
|
//批量新增
|
if(BooleanUtils.isFalse(listNew.isEmpty())) {
|
List<AdminRoleMenuRelationPO> list = listNew.stream()
|
.map(c -> {
|
AdminRoleMenuRelationPO item = new AdminRoleMenuRelationPO();
|
item.setRoleId(roleId);
|
item.setMenuId(c);
|
item.setCreateTime(now);
|
return item;
|
}).collect(Collectors.toList());
|
Boolean addList = roleMenuRelationDao.addList(list);
|
if(BooleanUtils.isFalse(addList)) {
|
return ExecutedResult.failed("给角色“" + roleId + "”新增菜单失败。" + listNew);
|
}
|
}
|
//批量删除
|
if(BooleanUtils.isFalse(listRemove.isEmpty())) {
|
List<Long> listId = listOld.stream()
|
.filter(c -> listRemove.contains(c.getMenuId()))
|
.map(AdminRoleMenuRelationPO::getId).collect(Collectors.toList());
|
Boolean removeList = roleMenuRelationDao.remove(listId);
|
if(BooleanUtils.isFalse(removeList)) {
|
return ExecutedResult.failed("删除角色“" + roleId + "”已有菜单失败。" + listRemove);
|
}
|
}
|
|
|
|
//找到角色已有的权限列表
|
List<AdminRolePermissionRelationPO> listOldPermission = rolePermissionRelationDao.list4Role(roleId);
|
listOldPermission = ParameterUtil.dealNull(listOldPermission);
|
List<Long> listOldPermissionId = listOldPermission.stream()
|
.map(AdminRolePermissionRelationPO::getPermissionId)
|
.collect(Collectors.toList());
|
|
//现在设置的权限id列表
|
List<Long> listPermissionId = ParameterUtil.dealNull(request.getListPermission());
|
|
//找到所有权限
|
List<Long> listAllPermissionId = new ArrayList<>(listOldPermissionId);
|
listAllPermissionId.addAll(listPermissionId);
|
ListUtil.repeat(listAllPermissionId);
|
List<AdminPermissionPO> listPermission = permissionDao.getList(listAllPermissionId);
|
Map<Long, AdminPermissionPO> mapPermission = listPermission.stream()
|
.collect(Collectors.toMap(AdminPermissionPO::getId, c -> c));
|
|
//找到新增权限列表(新权限列表的元素，不存在于已有的菜单列表中)
|
List<Long> listNewPermission = listPermissionId.stream()
|
.filter(c -> !listOldPermissionId.contains(c))
|
.collect(Collectors.toList());
|
//找到删除权限列表(已有权限列表的元素，不存在于新菜单列表)
|
List<Long> listRemovePermission = listOldPermissionId.stream()
|
.filter(c -> !listPermissionId.contains(c))
|
.collect(Collectors.toList());
|
|
//批量新增
|
if(BooleanUtils.isFalse(listNewPermission.isEmpty())) {
|
List<AdminRolePermissionRelationPO> list = listNewPermission.stream()
|
.map(c -> {
|
AdminRolePermissionRelationPO item = new AdminRolePermissionRelationPO();
|
item.setRoleId(roleId);
|
item.setPermissionId(c);
|
item.setCreateTime(now);
|
return item;
|
}).collect(Collectors.toList());
|
Boolean addList = rolePermissionRelationDao.addList(list);
|
if(BooleanUtils.isFalse(addList)) {
|
return ExecutedResult.failed("给角色“" + roleId + "”新增权限失败。" + listNewPermission);
|
}
|
}
|
//批量删除
|
if(BooleanUtils.isFalse(listRemovePermission.isEmpty())) {
|
List<Long> listId = listOldPermission.stream()
|
.filter(c -> listRemovePermission.contains(c.getPermissionId()))
|
.map(AdminRolePermissionRelationPO::getId).collect(Collectors.toList());
|
Boolean removeList = rolePermissionRelationDao.remove(listId);
|
if(BooleanUtils.isFalse(removeList)) {
|
return ExecutedResult.failed("删除角色“" + roleId + "”已有权限失败。" + listRemovePermission);
|
}
|
}
|
return ExecutedResult.success();
|
}
|
|
// 获取角色菜单权限列表
|
public ExecutedResult<ResAdminPower> getListMenu4Role(Long roleId) {
|
ResAdminPower result = new ResAdminPower();
|
result.setMenus(new ArrayList<>());
|
result.setPermissions(new ArrayList<>());
|
|
ExecutedResult<AdminRolePO> checkExists = this.checkRoleId(roleId);
|
if (checkExists.isFailed()) {
|
return ExecutedResult.failed(checkExists.getMsg());
|
}
|
AdminRolePO find = checkExists.getData();
|
//找到角色已有的菜单列表
|
List<AdminRoleMenuRelationPO> listMenu4Role = roleMenuRelationDao.list4Role(roleId);
|
if (ListUtil.isNotNullOrEmpty(listMenu4Role)) {
|
List<Long> listOldMenuId = listMenu4Role.stream()
|
.map(AdminRoleMenuRelationPO::getMenuId)
|
.collect(Collectors.toList());
|
List<AdminMenuPO> listMenu = menusDao.getList(listOldMenuId);
|
if (ListUtil.isNotNullOrEmpty(listMenu)) {
|
result.setMenus(AdminMenuConvert.INSTANCE.toVo(listMenu));
|
}
|
}
|
//找到角色已有的权限列表
|
List<AdminRolePermissionRelationPO> listPermission4Role = rolePermissionRelationDao.list4Role(roleId);
|
if (ListUtil.isNotNullOrEmpty(listPermission4Role)) {
|
List<Long> listPermissionId = listPermission4Role.stream()
|
.map(AdminRolePermissionRelationPO::getPermissionId)
|
.collect(Collectors.toList());
|
List<AdminPermissionPO> listPermission = permissionDao.getList(listPermissionId);
|
if (ListUtil.isNotNullOrEmpty(listPermission)) {
|
result.setPermissions(AdminPermissionConvert.INSTANCE.toDetail(listPermission));
|
}
|
}
|
return ExecutedResult.success(result);
|
}
|
|
protected List<AdminPermissionPO> getListPermission4Role(List<Long> listRoleId) {
|
List<AdminRolePermissionRelationPO> listPermissionRel = rolePermissionRelationDao.list4Role(listRoleId);
|
if (ListUtil.isNullOrEmpty(listPermissionRel)) {
|
return new ArrayList<>();
|
}
|
List<AdminPermissionPO> listPermission = permissionService.listAllWithCache();
|
if (ListUtil.isNullOrEmpty(listPermission)) {
|
return new ArrayList<>();
|
}
|
// 筛选状态
|
listPermission = listPermission.stream()
|
.filter(c -> Objects.equals(c.getStatus(), EState.NORMAL.getValue()))
|
.collect(Collectors.toList());
|
List<Long> listPermissionId = listPermissionRel.stream()
|
.map(AdminRolePermissionRelationPO::getPermissionId)
|
.collect(Collectors.toList());
|
return listPermission.stream()
|
.filter(c -> listPermissionId.contains(c.getId()))
|
.collect(Collectors.toList());
|
}
|
|
protected List<AdminMenuPO> getListMenu4Role(List<Long> listRoleId) {
|
List<AdminRoleMenuRelationPO> listRoleMenu = roleMenuRelationDao.list4Role(listRoleId);
|
if (ListUtil.isNullOrEmpty(listRoleMenu)) {
|
return new ArrayList<>();
|
}
|
List<AdminMenuPO> listMenu = menusService.listAllWithCache();
|
if (ListUtil.isNullOrEmpty(listMenu)) {
|
return new ArrayList<>();
|
}
|
// 筛选状态
|
listMenu = listMenu.stream()
|
.filter(c -> Objects.equals(c.getStatus(), EState.NORMAL.getValue()))
|
.collect(Collectors.toList());
|
List<Long> listMenuId = listRoleMenu.stream().map(AdminRoleMenuRelationPO::getMenuId)
|
.collect(Collectors.toList());
|
return listMenu.stream()
|
.filter(c -> listMenuId.contains(c.getId()))
|
.collect(Collectors.toList());
|
}
|
|
/**
|
* 删除指定用户的菜单和权限缓存
|
* @param userId 用户id
|
*/
|
protected void removePower4User(Long userId) {
|
menusService.removeUserMenuCache(userId);
|
permissionService.removeUserCache(userId);
|
}
|
/**
|
* 删除所有用户的菜单和权限缓存
|
*/
|
protected void removePowerAllUser() {
|
menusService.removeAllUserMenuCache();
|
permissionService.removeAllUserCache();
|
}
|
|
public ExecutedResult<String> setMenuSort(ReqSetSort request) {
|
// 验证记录是否存在
|
ExecutedResult<AdminMenuPO> checkExists = this.checkMenuId(request.getId());
|
if (checkExists.isFailed()) {
|
return ExecutedResult.failed(checkExists.getMsg());
|
}
|
|
AdminMenuPO item = new AdminMenuPO();
|
item.setId(request.getId());
|
item.setSort(request.getSort());
|
|
int rowCount = menusDao.updateById(item);
|
if (rowCount != 1) {
|
return ExecutedResult.failed("[测试信息]设置排序值失败。");
|
}
|
return ExecutedResult.success();
|
}
|
|
public ExecutedResult<String> listSetMenuSort(ReqListSetSort request) {
|
// id列表
|
List<Long> listId = request.getList().stream().map(ReqSetSort::getId).collect(Collectors.toList());
|
// 验证记录是否存在
|
ExecutedResult<List<AdminMenuPO>> checkExists = this.checkMenuId(listId);
|
if (checkExists.isFailed()) {
|
return ExecutedResult.failed(checkExists.getMsg());
|
}
|
|
List<AdminMenuPO> listUpdate = request.getList().stream()
|
.map(c -> {
|
AdminMenuPO item = new AdminMenuPO();
|
item.setId(c.getId());
|
item.setSort(c.getSort());
|
return item;
|
})
|
.collect(Collectors.toList());
|
Boolean result = menusDao.modifyList(listUpdate);
|
if (result) {
|
return ExecutedResult.success();
|
}
|
return ExecutedResult.failed("[测试信息]设置排序值失败");
|
}
|
|
public ExecutedResult<String> setRoleSort(ReqSetSort request) {
|
// 验证记录是否存在
|
ExecutedResult<AdminRolePO> checkExists = this.checkRoleId(request.getId());
|
if (checkExists.isFailed()) {
|
return ExecutedResult.failed(checkExists.getMsg());
|
}
|
|
AdminRolePO item = new AdminRolePO();
|
item.setId(request.getId());
|
item.setSort(request.getSort());
|
|
int rowCount = roleDao.updateById(item);
|
if (rowCount != 1) {
|
return ExecutedResult.failed("[角色]设置排序值失败。");
|
}
|
return ExecutedResult.success();
|
}
|
|
public ExecutedResult<String> listSetRoleSort(ReqListSetSort request) {
|
// id列表
|
List<Long> listId = request.getList().stream().map(ReqSetSort::getId).collect(Collectors.toList());
|
// 验证记录是否存在
|
ExecutedResult<List<AdminRolePO>> checkExists = this.checkRoleId(listId);
|
if (checkExists.isFailed()) {
|
return ExecutedResult.failed(checkExists.getMsg());
|
}
|
|
List<AdminRolePO> listUpdate = request.getList().stream()
|
.map(c -> {
|
AdminRolePO item = new AdminRolePO();
|
item.setId(c.getId());
|
item.setSort(c.getSort());
|
return item;
|
})
|
.collect(Collectors.toList());
|
Boolean result = roleDao.modifyList(listUpdate);
|
if (result) {
|
return ExecutedResult.success();
|
}
|
return ExecutedResult.failed("[角色]设置排序值失败");
|
}
|
}
|
