admin/MaxKey
1
0
Fork 0
mirror of https://gitee.com/dromara/MaxKey.git synced 2025-12-06 17:08:29 +08:00
Code Issues Packages Projects Releases Wiki Activity

modify

Browse Source
This commit is contained in:
MaxKey 2022-04-03 19:56:18 +08:00
parent 0586a2a559
commit 0dd0dba14f
6 changed files with 88 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
maxkey-core/src/main/java/org/maxkey/entity/RolePermissions.java → maxkey-core/src/main/java/org/maxkey/entity/RolePrivileges.java
View File

@ -29,8 +29,8 @@ import org.maxkey.constants.ConstsStatus;
import org.maxkey.web.WebContext;
@Entity
@Table(name = "MXK_ROLE_PERMISSIONS")
public class RolePermissions extends JpaBaseEntity implements Serializable {
@Table(name = "MXK_ROLE_PRIVILEGES")
public class RolePrivileges extends JpaBaseEntity implements Serializable {
private static final long serialVersionUID = -8783585691243853899L;
@Id
@ -50,10 +50,10 @@ public class RolePermissions extends JpaBaseEntity implements Serializable {
private String instName;
public RolePermissions() {
public RolePrivileges() {
}
public RolePermissions(String appId, String roleId, String instId) {
public RolePrivileges(String appId, String roleId, String instId) {
this.appId = appId;
this.roleId = roleId;
this.instId = instId;
@ -65,7 +65,7 @@ public class RolePermissions extends JpaBaseEntity implements Serializable {
* @param roleId String
* @param resourceId String
*/
public RolePermissions(String appId, String roleId, String resourceId , String instId) {
public RolePrivileges(String appId, String roleId, String resourceId , String instId) {
this.id = WebContext.genId();
this.appId = appId;
this.roleId = roleId;
@ -136,7 +136,7 @@ public class RolePermissions extends JpaBaseEntity implements Serializable {
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
builder.append("RolePermissions [id=");
builder.append("RolePrivileges [id=");
builder.append(id);
builder.append(", appId=");
builder.append(appId);

8
maxkey-persistence/src/main/java/org/maxkey/persistence/mapper/RolesMapper.java
View File

@ -23,7 +23,7 @@ package org.maxkey.persistence.mapper;
import java.util.List;
import org.apache.mybatis.jpa.persistence.IJpaBaseMapper;
import org.maxkey.entity.RolePermissions;
import org.maxkey.entity.RolePrivileges;
import org.maxkey.entity.Roles;
/**
@ -33,11 +33,11 @@ import org.maxkey.entity.Roles;
public interface RolesMapper extends IJpaBaseMapper<Roles> {
public int insertRolePermissions(List<RolePermissions> rolePermissionsList);
public int insertRolePrivileges(List<RolePrivileges> rolePermissionsList);
public int logisticDeleteRolePermissions(List<RolePermissions> rolePermissionsList);
public int deleteRolePrivileges(List<RolePrivileges> rolePermissionsList);
public List<RolePermissions> queryRolePermissions(RolePermissions rolePermissions);
public List<RolePrivileges> queryRolePrivileges(RolePrivileges rolePermissions);
public List<Roles> queryDynamicRoles(Roles role);
}

14
maxkey-persistence/src/main/java/org/maxkey/persistence/service/RolesService.java
View File

@ -20,7 +20,7 @@ package org.maxkey.persistence.service;
import java.util.List;
import org.apache.mybatis.jpa.persistence.JpaBaseService;
import org.maxkey.entity.RolePermissions;
import org.maxkey.entity.RolePrivileges;
import org.maxkey.entity.Roles;
import org.maxkey.persistence.mapper.RolesMapper;
import org.maxkey.util.StringUtils;
@ -50,16 +50,16 @@ public class RolesService extends JpaBaseService<Roles>{
return (RolesMapper)super.getMapper();
}
public boolean insertRolePermissions(List<RolePermissions> rolePermissionsList) {
return getMapper().insertRolePermissions(rolePermissionsList)>0;
public boolean insertRolePrivileges(List<RolePrivileges> rolePermissionsList) {
return getMapper().insertRolePrivileges(rolePermissionsList)>0;
};
public boolean logisticDeleteRolePermissions(List<RolePermissions> rolePermissionsList) {
return getMapper().logisticDeleteRolePermissions(rolePermissionsList)>=0;
public boolean deleteRolePrivileges(List<RolePrivileges> rolePermissionsList) {
return getMapper().deleteRolePrivileges(rolePermissionsList)>=0;
}
public List<RolePermissions> queryRolePermissions(RolePermissions rolePermissions){
return getMapper().queryRolePermissions(rolePermissions);
public List<RolePrivileges> queryRolePrivileges(RolePrivileges rolePermissions){
return getMapper().queryRolePrivileges(rolePermissions);
}
public List<Roles> queryDynamicRoles(Roles dynamicRole){

12
maxkey-persistence/src/main/resources/org/maxkey/persistence/mapper/xml/mysql/RolesMapper.xml
View File

@ -56,11 +56,11 @@
</update>
<select id="queryRolePermissions" parameterType="RolePermissions" resultType="RolePermissions">
<select id="queryRolePrivileges" parameterType="RolePrivileges" resultType="RolePrivileges">
select
*
from
mxk_role_permissions
mxk_role_privileges
where instid = #{instId}
and status = 1
<if test="id != null and id != ''">
@ -75,8 +75,8 @@
</select>
<update id="logisticDeleteRolePermissions" parameterType="java.util.List">
update mxk_role_permissions
<update id="deleteRolePrivileges" parameterType="java.util.List">
update mxk_role_privileges
set status = 9
where 1 = 1 and
<foreach item="item" collection="list" open="(" separator="or" close=")">
@ -84,8 +84,8 @@
</foreach>
</update>
<insert id="insertRolePermissions" parameterType="java.util.List">
insert into mxk_role_permissions ( id,appid,roleid,resourceid,status,instid)
<insert id="insertRolePrivileges" parameterType="java.util.List">
insert into mxk_role_privileges ( id,appid,roleid,resourceid,status,instid)
values
<foreach collection="list" item="item" index="index" separator=",">
(#{item.id},#{item.appId},#{item.roleId},#{item.resourceId},#{item.status},#{item.instId})

14
maxkey-webs/maxkey-web-mgt/src/main/java/org/maxkey/web/permissions/contorller/RoleMemberController.java
View File

@ -63,9 +63,9 @@ public class RoleMemberController {
@RequestMapping(value = { "/memberInRole" })
@ResponseBody
public ResponseEntity<?> memberInRole(@ModelAttribute RoleMember roleMember) {
public ResponseEntity<?> memberInRole(@ModelAttribute RoleMember roleMember,@CurrentUser UserInfo currentUser) {
_logger.debug("roleMember : "+roleMember);
roleMember.setInstId(WebContext.getUserInfo().getInstId());
roleMember.setInstId(currentUser.getInstId());
if(roleMember.getRoleId()==null||roleMember.getRoleId().equals("")||roleMember.getRoleId().equals("ALL_USER_ROLE")){
return new Message<JpaPageResults<RoleMember>>(
roleMemberService.queryPageResults("allMemberInRole",roleMember)).buildResponse();
@ -77,15 +77,15 @@ public class RoleMemberController {
@RequestMapping(value = { "/memberNotInRole" })
@ResponseBody
public ResponseEntity<?> memberNotInRole(@ModelAttribute RoleMember roleMember) {
roleMember.setInstId(WebContext.getUserInfo().getInstId());
public ResponseEntity<?> memberNotInRole(@ModelAttribute RoleMember roleMember,@CurrentUser UserInfo currentUser) {
roleMember.setInstId(currentUser.getInstId());
return new Message<JpaPageResults<RoleMember>>(
roleMemberService.queryPageResults("memberNotInGroup",roleMember)).buildResponse();
roleMemberService.queryPageResults("memberNotInRole",roleMember)).buildResponse();
}
@RequestMapping(value = {"/add"})
@ResponseBody
public ResponseEntity<?> add(@ModelAttribute RoleMember roleMember) {
public ResponseEntity<?> add(@ModelAttribute RoleMember roleMember,@CurrentUser UserInfo currentUser) {
if (roleMember == null || roleMember.getRoleId() == null) {
return new Message<RoleMember>(Message.FAIL).buildResponse();
}
@ -106,7 +106,7 @@ public class RoleMemberController {
arrMemberIds[i],
arrMemberNames[i],
"USER",
WebContext.getUserInfo().getInstId());
currentUser.getInstId());
newRoleMember.setId(WebContext.genId());
result = roleMemberService.insert(newRoleMember);
}

118
maxkey-webs/maxkey-web-mgt/src/main/java/org/maxkey/web/permissions/contorller/RolePrivilegesController.java
View File

@ -21,22 +21,22 @@ import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import org.maxkey.constants.ConstsOperateMessage;
import org.maxkey.entity.RolePermissions;
import org.maxkey.authn.annotation.CurrentUser;
import org.maxkey.entity.Message;
import org.maxkey.entity.RolePrivileges;
import org.maxkey.entity.UserInfo;
import org.maxkey.persistence.service.RolesService;
import org.maxkey.util.StringUtils;
import org.maxkey.web.WebContext;
import org.maxkey.web.message.Message;
import org.maxkey.web.message.MessageType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;
@Controller
@ -47,85 +47,83 @@ public class RolePrivilegesController {
@Autowired
@Qualifier("rolesService")
RolesService rolesService;
@RequestMapping(value={"/list"})
public ModelAndView resourcesList(){
return new ModelAndView("permissions/permissionsList");
}
@ResponseBody
@RequestMapping(value={"/savepermissions"})
public Message insert(@ModelAttribute("rolePermissions") RolePermissions rolePermissions) {
_logger.debug("-save :" + rolePermissions);
@RequestMapping(value={"/update"}, produces = {MediaType.APPLICATION_JSON_VALUE})
public ResponseEntity<?> update(
@ModelAttribute RolePrivileges rolePrivileges,
@CurrentUser UserInfo currentUser) {
_logger.debug("-update : " + rolePrivileges);
//have
String instId = WebContext.getUserInfo().getInstId();
RolePermissions queryRolePermissions =
new RolePermissions(
rolePermissions.getAppId(),
rolePermissions.getRoleId(),
instId);
List<RolePermissions> rolePermissionsedList = rolesService.queryRolePermissions(queryRolePermissions);
RolePrivileges queryRolePrivileges =
new RolePrivileges(
rolePrivileges.getAppId(),
rolePrivileges.getRoleId(),
currentUser.getInstId());
List<RolePrivileges> roleRolePrivilegesList = rolesService.queryRolePrivileges(queryRolePrivileges);
HashMap<String,String >permedMap =new HashMap<String,String >();
for(RolePermissions rolePerms : rolePermissionsedList) {
permedMap.put(rolePerms.getUniqueId(),rolePerms.getId());
HashMap<String,String >privilegeMap =new HashMap<String,String >();
for(RolePrivileges rolePrivilege : roleRolePrivilegesList) {
privilegeMap.put(rolePrivilege.getUniqueId(),rolePrivilege.getId());
}
//Maybe insert
ArrayList<RolePermissions> rolePermissionsList =new ArrayList<RolePermissions>();
List<String>resourceIds = StringUtils.string2List(rolePermissions.getResourceId(), ",");
HashMap<String,String >newPermsMap =new HashMap<String,String >();
ArrayList<RolePrivileges> newRolePrivilegesList =new ArrayList<RolePrivileges>();
List<String>resourceIds = StringUtils.string2List(rolePrivileges.getResourceId(), ",");
HashMap<String,String >newPrivilegesMap =new HashMap<String,String >();
for(String resourceId : resourceIds) {
RolePermissions newRolePermissions=new RolePermissions(
rolePermissions.getAppId(),
rolePermissions.getRoleId(),
RolePrivileges newRolePrivilege=new RolePrivileges(
rolePrivileges.getAppId(),
rolePrivileges.getRoleId(),
resourceId,
instId);
newRolePermissions.setId(newRolePermissions.generateId());
newPermsMap.put(newRolePermissions.getUniqueId(), rolePermissions.getAppId());
currentUser.getInstId());
newRolePrivilege.setId(newRolePrivilege.generateId());
newPrivilegesMap.put(newRolePrivilege.getUniqueId(), rolePrivileges.getAppId());
if(!rolePermissions.getAppId().equalsIgnoreCase(resourceId) &&
!permedMap.containsKey(newRolePermissions.getUniqueId())) {
rolePermissionsList.add(newRolePermissions);
if(!rolePrivileges.getAppId().equalsIgnoreCase(resourceId) &&
!privilegeMap.containsKey(newRolePrivilege.getUniqueId())) {
newRolePrivilegesList.add(newRolePrivilege);
}
}
//delete
ArrayList<RolePermissions> deleteRolePermissionsList =new ArrayList<RolePermissions>();
for(RolePermissions rolePerms : rolePermissionsedList) {
if(!newPermsMap.containsKey(rolePerms.getUniqueId())) {
rolePerms.setInstId(instId);
deleteRolePermissionsList.add(rolePerms);
ArrayList<RolePrivileges> deleteRolePrivilegesList =new ArrayList<RolePrivileges>();
for(RolePrivileges rolePrivilege : roleRolePrivilegesList) {
if(!newPrivilegesMap.containsKey(rolePrivilege.getUniqueId())) {
rolePrivilege.setInstId(currentUser.getInstId());
deleteRolePrivilegesList.add(rolePrivilege);
}
}
if (!deleteRolePermissionsList.isEmpty()) {
rolesService.logisticDeleteRolePermissions(deleteRolePermissionsList);
if (!deleteRolePrivilegesList.isEmpty()) {
_logger.debug("-remove : " + deleteRolePrivilegesList);
rolesService.deleteRolePrivileges(deleteRolePrivilegesList);
}
if (!rolePermissionsList.isEmpty() && rolesService.insertRolePermissions(rolePermissionsList)) {
return new Message(WebContext.getI18nValue(ConstsOperateMessage.INSERT_SUCCESS),MessageType.success);
if (!newRolePrivilegesList.isEmpty() && rolesService.insertRolePrivileges(newRolePrivilegesList)) {
_logger.debug("-insert : " + newRolePrivilegesList);
return new Message<RolePrivileges>(Message.SUCCESS).buildResponse();
} else {
return new Message(WebContext.getI18nValue(ConstsOperateMessage.INSERT_SUCCESS),MessageType.error);
return new Message<RolePrivileges>(Message.SUCCESS).buildResponse();
}
}
@ResponseBody
@RequestMapping(value={"/querypermissions"})
public List<RolePermissions> querypermissions(@ModelAttribute("rolePermissions") RolePermissions rolePermissions) {
_logger.debug("-querypermissions :" + rolePermissions);
@RequestMapping(value={"/get"}, produces = {MediaType.APPLICATION_JSON_VALUE})
public ResponseEntity<?> get(
@ModelAttribute RolePrivileges rolePrivileges,
@CurrentUser UserInfo currentUser) {
_logger.debug("-get :" + rolePrivileges);
//have
RolePermissions queryRolePermissions =
new RolePermissions(
rolePermissions.getAppId(),
rolePermissions.getRoleId(),
WebContext.getUserInfo().getInstId());
List<RolePermissions> rolePermissionsedList = rolesService.queryRolePermissions(queryRolePermissions);
return rolePermissionsedList;
RolePrivileges queryRolePrivilege =
new RolePrivileges(
rolePrivileges.getAppId(),
rolePrivileges.getRoleId(),
currentUser.getInstId());
List<RolePrivileges> rolePrivilegeList = rolesService.queryRolePrivileges(queryRolePrivilege);
return new Message<List<RolePrivileges>>(
rolePrivilegeList).buildResponse();
}