package com.lxzn.ucenter.service.impl;
|
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.additional.query.impl.LambdaQueryChainWrapper;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.lxzn.framework.domain.ucenter.*;
|
import com.lxzn.framework.domain.ucenter.ext.MenuExt;
|
import com.lxzn.framework.domain.ucenter.request.RoleRequest;
|
import com.lxzn.framework.domain.ucenter.response.RoleCode;
|
import com.lxzn.framework.exception.ExceptionCast;
|
import com.lxzn.framework.model.response.CommonCode;
|
import com.lxzn.framework.model.response.CommonJsonTree;
|
import com.lxzn.framework.model.response.QueryPageResponseResult;
|
import com.lxzn.framework.utils.ValidateUtil;
|
import com.lxzn.ucenter.dao.RoleMapper;
|
import com.lxzn.ucenter.service.*;
|
import com.lxzn.ucenter.service.support.MenuButtonTreeWrapper;
|
import com.lxzn.ucenter.service.support.MenuPermissonTreeWrapper;
|
import com.lxzn.ucenter.service.support.ObjectButtonTreeWrapper;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.util.*;
|
|
@Service
|
public class RoleServiceImpl extends ServiceImpl<RoleMapper, Role> implements IRoleService {
|
|
@Autowired
|
private IMenuPermissionService menuPermissionService;
|
@Autowired
|
private IButtonPermissionService buttonPermissionService;
|
@Autowired
|
private IMenuButtonPermissionService menuButtonPermissionService;
|
@Autowired
|
private IObjectButtonPermissionService objectButtonPermissionService;
|
@Autowired
|
private IMenuService menuService;
|
@Autowired
|
private IObjectService objectService;
|
@Autowired
|
private IMenuButtonService menuButtonService;
|
@Autowired
|
private IObjectButtonService objectButtonService;
|
@Autowired
|
private IButtonService buttonService;
|
@Autowired
|
private IUserRoleService userRoleService;
|
|
@Override
|
@Transactional(rollbackFor = {Exception.class})
|
public boolean addRole(Role role) {
|
if(role == null)
|
ExceptionCast.cast(CommonCode.INVALID_PARAM);
|
if(!ValidateUtil.validateString(role.getRoleCode()))
|
ExceptionCast.cast(RoleCode.ROLE_CODE_NONE);
|
if(!ValidateUtil.validateString(role.getRoleName()))
|
ExceptionCast.cast(RoleCode.ROLE_NAME_NONE);
|
Role en = this.getByRoleCode(role.getRoleCode());
|
if(en != null)
|
ExceptionCast.cast(RoleCode.ROLE_CODE_EXIST);
|
return super.save(role);
|
}
|
|
@Override
|
public Role getByRoleCode(String roleCode) {
|
if(!ValidateUtil.validateString(roleCode))
|
return null;
|
List<Role> roleList = super.lambdaQuery().eq(Role::getRoleCode, roleCode).list();
|
if(roleList == null || roleList.isEmpty())
|
return null;
|
return roleList.get(0);
|
}
|
|
@Override
|
@Transactional(rollbackFor = {Exception.class})
|
public boolean assignMenus(String roleId, String[] menuIds) {
|
if(!ValidateUtil.validateString(roleId))
|
ExceptionCast.cast(RoleCode.ROLE_ID_NONE);
|
Role role = super.getById(roleId);
|
if(role == null)
|
ExceptionCast.cast(RoleCode.ROLE_NOT_EXIST);
|
if(menuIds == null || menuIds.length < 1)
|
ExceptionCast.cast(RoleCode.ROLE_MENU_NONE);
|
List<String> ids = new ArrayList<>(menuIds.length);
|
Collections.addAll(ids, menuIds);
|
Collection<Menu> menuList = menuService.listByIds(ids);
|
if(menuList == null || menuList.isEmpty() || menuList.size() != menuIds.length)
|
ExceptionCast.cast(CommonCode.INVALID_PARAM);
|
boolean b = menuPermissionService.deleteByRoleId(roleId);
|
if(!b)
|
ExceptionCast.cast(CommonCode.FAIL);
|
List<MenuPermission> menuPermissions = new ArrayList<>();
|
menuList.forEach(item -> {
|
final MenuPermission en = new MenuPermission();
|
en.setRoleId(role.getRoleId());
|
en.setMenuId(item.getMenuId());
|
menuPermissions.add(en);
|
});
|
if(!menuPermissions.isEmpty())
|
return menuPermissionService.saveBatch(menuPermissions);
|
return b;
|
}
|
|
@Override
|
@Transactional(rollbackFor = {Exception.class})
|
public boolean assignSysButton(String roleId, String[] buttonIds) {
|
if(!ValidateUtil.validateString(roleId))
|
ExceptionCast.cast(RoleCode.ROLE_ID_NONE);
|
Role role = super.getById(roleId);
|
if(role == null)
|
ExceptionCast.cast(RoleCode.ROLE_NOT_EXIST);
|
if(buttonIds == null || buttonIds.length < 1) {
|
boolean b = buttonPermissionService.deleteByRoleId(roleId);
|
if(!b)
|
ExceptionCast.cast(CommonCode.FAIL);
|
return b;
|
}
|
List<String> ids = new ArrayList<>(buttonIds.length);
|
Collections.addAll(ids, buttonIds);
|
Collection<Button> buttonList = buttonService.listByIds(ids);
|
if(buttonList == null || buttonList.isEmpty() || buttonList.size() != buttonIds.length)
|
ExceptionCast.cast(CommonCode.INVALID_PARAM);
|
boolean b = buttonPermissionService.deleteByRoleId(roleId);
|
if(!b)
|
ExceptionCast.cast(CommonCode.FAIL);
|
List<ButtonPermission> buttonPermissions = new ArrayList<>();
|
buttonList.forEach(item -> {
|
final ButtonPermission en = new ButtonPermission();
|
en.setRoleId(role.getRoleId());
|
en.setButtonId(item.getButtonId());
|
buttonPermissions.add(en);
|
});
|
if(!buttonPermissions.isEmpty())
|
return buttonPermissionService.saveBatch(buttonPermissions);
|
return b;
|
}
|
|
@Override
|
@Transactional(rollbackFor = {Exception.class})
|
public boolean assignMenuButton(String roleId, String[] menuButtonIds) {
|
if(!ValidateUtil.validateString(roleId))
|
ExceptionCast.cast(RoleCode.ROLE_ID_NONE);
|
Role role = super.getById(roleId);
|
if(role == null)
|
ExceptionCast.cast(RoleCode.ROLE_NOT_EXIST);
|
if(menuButtonIds == null || menuButtonIds.length < 1) {
|
return menuButtonPermissionService.deleteByRoleId(roleId);
|
}
|
List<String> ids = new ArrayList<>(menuButtonIds.length);
|
Collections.addAll(ids, menuButtonIds);
|
Collection<MenuButton> menuButtonList = menuButtonService.listByIds(ids);
|
if(menuButtonList == null || menuButtonList.isEmpty() || menuButtonList.size() != menuButtonIds.length)
|
ExceptionCast.cast(CommonCode.INVALID_PARAM);
|
boolean b = menuButtonPermissionService.deleteByRoleId(roleId);
|
if(!b)
|
ExceptionCast.cast(CommonCode.FAIL);
|
List<MenuButtonPermission> menuButtonPermissions = new ArrayList<>();
|
menuButtonList.forEach(item -> {
|
final MenuButtonPermission en = new MenuButtonPermission();
|
en.setRoleId(role.getRoleId());
|
en.setMenuId(item.getMenuId());
|
en.setButtonId(item.getButtonId());
|
menuButtonPermissions.add(en);
|
});
|
if(!menuButtonPermissions.isEmpty())
|
return menuButtonPermissionService.saveBatch(menuButtonPermissions);
|
return b;
|
}
|
|
@Override
|
@Transactional(rollbackFor = {Exception.class})
|
public boolean assignObjectButton(String roleId, String[] objectButtonIds) {
|
if(!ValidateUtil.validateString(roleId))
|
ExceptionCast.cast(RoleCode.ROLE_ID_NONE);
|
Role role = super.getById(roleId);
|
if(role == null)
|
ExceptionCast.cast(RoleCode.ROLE_NOT_EXIST);
|
if(objectButtonIds == null || objectButtonIds.length < 1) {
|
return objectButtonPermissionService.deleteByRoleId(roleId);
|
}
|
List<String> ids = new ArrayList<>(objectButtonIds.length);
|
Collections.addAll(ids, objectButtonIds);
|
Collection<ObjectButton> objectButtonList = objectButtonService.listByIds(ids);
|
if(objectButtonList == null || objectButtonList.isEmpty() || objectButtonList.size() != objectButtonIds.length)
|
ExceptionCast.cast(CommonCode.INVALID_PARAM);
|
boolean b = objectButtonPermissionService.deleteByRoleId(roleId);
|
if(!b)
|
ExceptionCast.cast(CommonCode.FAIL);
|
List<ObjectButtonPermission> objectButtonPermissions = new ArrayList<>();
|
objectButtonList.forEach(item -> {
|
final ObjectButtonPermission en = new ObjectButtonPermission();
|
en.setRoleId(role.getRoleId());
|
en.setObjectId(item.getObjectId());
|
en.setButtonId(item.getButtonId());
|
objectButtonPermissions.add(en);
|
});
|
if(!objectButtonPermissions.isEmpty())
|
return objectButtonPermissionService.saveBatch(objectButtonPermissions);
|
return b;
|
}
|
|
@Override
|
public List<Role> getUserNonPermRole(String userId) {
|
return super.getBaseMapper().getUserNonPermRole(userId);
|
}
|
|
@Override
|
public List<Role> getUserPermRole(String userId) {
|
return super.getBaseMapper().getUserPermRole(userId);
|
}
|
|
@Override
|
public QueryPageResponseResult<Role> findPageList(int page, int size, RoleRequest roleRequest) {
|
if(page < 1 || size < 1) {
|
ExceptionCast.cast(CommonCode.INVALID_PAGE);
|
}
|
IPage<Role> pageData = new Page<>(page, size);
|
LambdaQueryChainWrapper<Role> lambdaQuery = super.lambdaQuery();
|
if(roleRequest != null) {
|
if(ValidateUtil.validateString(roleRequest.getRoleCode())) {
|
lambdaQuery.like(Role::getRoleCode, roleRequest.getRoleCode());
|
}
|
if(ValidateUtil.validateString(roleRequest.getRoleName())) {
|
lambdaQuery.like(Role::getRoleName, roleRequest.getRoleName());
|
}
|
|
if(ValidateUtil.validateString(roleRequest.getAscStr())) {
|
String[] ascArr = roleRequest.getAscStr().split(",");
|
((Page<Role>) pageData).setAsc(ascArr);
|
}
|
if(ValidateUtil.validateString(roleRequest.getDescStr())) {
|
String[] descStr = roleRequest.getDescStr().split(",");
|
((Page<Role>) pageData).setDesc(descStr);
|
}
|
}
|
IPage<Role> roleIPage = lambdaQuery.page(pageData);
|
return new QueryPageResponseResult<>(CommonCode.SUCCESS, roleIPage);
|
}
|
|
@Override
|
@Transactional(rollbackFor = {Exception.class})
|
public boolean editRole(String id, Role role) {
|
if(!ValidateUtil.validateString(id) || role == null)
|
ExceptionCast.cast(CommonCode.INVALID_PARAM);
|
Role en = super.getById(id);
|
if(en == null)
|
ExceptionCast.cast(RoleCode.ROLE_NOT_EXIST);
|
role.setRoleId(id);
|
role.setRoleCode(null);
|
return super.updateById(role);
|
}
|
|
@Override
|
public List<CommonJsonTree> getMenuButtonTree(String roleId) {
|
if(!ValidateUtil.validateString(roleId))
|
return null;
|
List<Menu> menuList = menuService.getLeafMenuList();
|
if(menuList == null || menuList.isEmpty())
|
return null;
|
List<MenuButton> menuButtonList = menuButtonService.list();
|
if(menuButtonList == null || menuButtonList.isEmpty())
|
return null;
|
Map<String, MenuButtonPermission> map = menuButtonPermissionService.getMapByRoleId(roleId);
|
return MenuButtonTreeWrapper.loadTree(menuList, menuButtonList, map);
|
}
|
|
@Override
|
public List<CommonJsonTree> getObjectButtonTree(String roleId) {
|
if(!ValidateUtil.validateString(roleId))
|
return null;
|
List<ObjectBase> objectBaseList = objectService.list();
|
if(objectBaseList == null || objectBaseList.isEmpty())
|
return null;
|
List<ObjectButton> objectButtonList = objectButtonService.list();
|
if(objectButtonList == null || objectButtonList.isEmpty())
|
return null;
|
Map<String, ObjectButtonPermission> map = objectButtonPermissionService.getMapByRoleId(roleId);
|
return ObjectButtonTreeWrapper.loadTree(objectBaseList, objectButtonList, map);
|
}
|
|
@Override
|
public List<CommonJsonTree> getMenuTree(String roleId) {
|
if(!ValidateUtil.validateString(roleId))
|
return null;
|
List<MenuExt> menuList = menuService.findAll();
|
if(menuList == null || menuList.isEmpty())
|
return null;
|
Map<String, MenuPermission> menuPermissionMap = menuPermissionService.getMapByRoleId(roleId);
|
if(menuPermissionMap == null)
|
menuPermissionMap = new HashMap<>();
|
return MenuPermissonTreeWrapper.loadTree(menuList, menuPermissionMap);
|
}
|
|
@Override
|
@Transactional(rollbackFor = {Exception.class})
|
public boolean deleteRole(String roleId) {
|
if(!ValidateUtil.validateString(roleId))
|
ExceptionCast.cast(CommonCode.INVALID_PARAM);
|
Role en = super.getById(roleId);
|
if(en == null)
|
ExceptionCast.cast(RoleCode.ROLE_NOT_EXIST);
|
List<UserRole> userRoleList = userRoleService.findByRoleId(roleId);
|
if(userRoleList != null && !userRoleList.isEmpty())
|
ExceptionCast.cast(RoleCode.ROLE_USER_EXIST);
|
boolean b = buttonPermissionService.deleteByRoleId(roleId);
|
if(!b)
|
ExceptionCast.cast(CommonCode.FAIL);
|
b = menuPermissionService.deleteByRoleId(roleId);
|
if(!b)
|
ExceptionCast.cast(CommonCode.FAIL);
|
b = menuButtonPermissionService.deleteByRoleId(roleId);
|
if(!b)
|
ExceptionCast.cast(CommonCode.FAIL);
|
b = objectButtonPermissionService.deleteByRoleId(roleId);
|
if(!b)
|
ExceptionCast.cast(CommonCode.FAIL);
|
return super.removeById(roleId);
|
}
|
}
|
