modify

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

@@ -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);

maxkey-persistence/src/main/java/org/maxkey/persistence/mapper/RolesMapper.java

@@ -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);
 }

maxkey-persistence/src/main/java/org/maxkey/persistence/service/RolesService.java

@@ -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){

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

@@ -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})

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

@@ -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);
 			}

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

@@ -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();
 	}