?? rolemgrimpl.java
字號:
package com.yuanchung.sales.service.admin.role.impl;
import java.util.ArrayList;
import java.util.List;
import org.apache.log4j.Logger;
import com.yuanchung.organize.treeview.TreeViewMgr;
import com.yuanchung.sales.constants.DataBaseTableName;
import com.yuanchung.sales.dao.admin.role.RoleDAO;
import com.yuanchung.sales.dao.admin.role.RoleRightAreaDAO;
import com.yuanchung.sales.dao.admin.role.RoleRightsDAO;
import com.yuanchung.sales.dao.admin.role.UserRoleDAO;
import com.yuanchung.sales.dao.util.UtilDAO;
import com.yuanchung.sales.exception.SystemException;
import com.yuanchung.sales.model.admin.Rights;
import com.yuanchung.sales.model.admin.role.Role;
import com.yuanchung.sales.model.admin.role.RoleRightArea;
import com.yuanchung.sales.model.admin.role.RoleRights;
import com.yuanchung.sales.model.admin.role.UserRole;
import com.yuanchung.sales.service.admin.authorization.AuthorizationMgr;
import com.yuanchung.sales.service.admin.role.RoleMgr;
import com.yuanchung.sales.util.Constants;
public class RoleMgrImpl implements RoleMgr {
private Logger log = Logger.getLogger(RoleMgrImpl.class);
private RoleDAO roleDAO;
private static UserRoleDAO userRoleDAO;
private RoleRightsDAO roleRightsDAO;
private RoleRightAreaDAO roleRightAreaDAO;
private TreeViewMgr treeViewMgr;
private UtilDAO utilDao;
private AuthorizationMgr authorizationMgr;
public AuthorizationMgr getAuthorizationMgr() {
return authorizationMgr;
}
public void setAuthorizationMgr(AuthorizationMgr authorizationMgr) {
this.authorizationMgr = authorizationMgr;
}
public UtilDAO getUtilDao() {
return utilDao;
}
public void setUtilDao(UtilDAO utilDao) {
this.utilDao = utilDao;
}
public RoleRightAreaDAO getRoleRightAreaDAO() {
return roleRightAreaDAO;
}
public void setRoleRightAreaDAO(RoleRightAreaDAO roleRightAreaDAO) {
this.roleRightAreaDAO = roleRightAreaDAO;
}
public TreeViewMgr getTreeViewMgr() {
return treeViewMgr;
}
public void setTreeViewMgr(TreeViewMgr treeViewMgr) {
this.treeViewMgr = treeViewMgr;
}
public RoleRightsDAO getRoleRightsDAO() {
return roleRightsDAO;
}
public void setRoleRightsDAO(RoleRightsDAO roleRightsDAO) {
this.roleRightsDAO = roleRightsDAO;
}
public RoleDAO getRoleDAO() {
return roleDAO;
}
public void setRoleDAO(RoleDAO roleDAO) {
this.roleDAO = roleDAO;
}
/**
* 鑾峰彇鎵?鏈夎鑹?
*
* @return List<Role>
*/
public List<Role> findAll() {
return roleDAO.findAll();
}
/**
* 鏍規嵁瑙掕壊ID鑾峰彇瑙掕壊瀵硅薄
*
* @param int
* @return Role
*/
public Role findById(int roleId) {
Role role = roleDAO.findById(roleId);
return role;
}
/**
* 鏍規嵁瑙掕壊ID鑾峰彇鎵?鏈夋潈闄愬璞?
*
* @param int
* @return List<RoleRights>
*/
public List<RoleRights> getRightsByRoleId(int roleId) {
List<RoleRights> roleRights = roleRightsDAO.findByRoleId(roleId);
return roleRights;
}
public List<RoleRightArea> getDataAreaByRightIdRoleId(int rightsId,
int roleId) {
List<RoleRightArea> roleRightArea = roleRightAreaDAO
.getDataAreaByRightIdRoleId(rightsId, roleId);
return roleRightArea;
}
/**
* 根據角色權限集合刪除角色權限數據范圍關聯表里的信息
*
* @param List
* <PositionRights>
*/
public void deleteRoleRightsAreaByRoleRights(List<RoleRights> rr) {
for (int i = 0; i < rr.size(); i++) {
// 先根據角色權限ID獲取對象集合,再遍歷對象集合進行刪除
log.debug("角色權限ID是: " + rr.get(i).getId());
List<RoleRightArea> roleRightAreas = roleRightAreaDAO
.findByRoleRightsId(rr.get(i).getId());
log.debug("角色權限的數據范圍大小: " + roleRightAreas.size());
for (int j = 0; j < roleRightAreas.size(); j++) {
roleRightAreaDAO.delete(roleRightAreas.get(j));
}
}
}
/**
* 根據角色權限集合刪除角色權限關聯表里的信息
*
* @param List
* <PositionRights>
*/
public void deleteRoleRightsByRoleRights(List<RoleRights> rr) {
for (int i = 0; i < rr.size(); i++) {
RoleRights roleRight = rr.get(i);
roleRightsDAO.delete(roleRight);
}
}
/**
* 根據角色ID獲取角色權限關聯表里的信息
*
* @param List
* <PositionRights>
*/
public List<RoleRights> findByRole(int roleId) {
List<RoleRights> rights = roleRightsDAO.findByRoleId(roleId);
return rights;
}
/**
* 保存授權對象, 權限對象以及數據范圍對象三者的關系
*
* @param int
* roleId 角色ID
* @param int
* rightId 權限ID
* @param String
* dataAreaIds 數據范圍域字符串
* @throws SystemException
*/
public void saveThreeObjRelation(int roleId, int rightId, String dataAreaIds) {
log.debug("數據范圍是: " + dataAreaIds);
String[] areaIds = dataAreaIds.split(",");
log.debug("拆分后的數據范圍是: " + areaIds.length);
// 實例化一個新對象(角色權限關聯表)
RoleRights rr = new RoleRights();
// 設值
log.debug("roleId= " + roleId);
log.debug("rightId= " + rightId);
rr.setRoleId(roleId);
rr.setRightsId(rightId);
// 調用Hibernate DAO保存
roleRightsDAO.save(rr);
// 獲取最大ID,也就是新插入的記錄ID
int roleRightsId = roleRightsDAO.getMaxId();
log.debug("roleRightsId" + roleRightsId);
// 實例化一個新對象(角色權限數據范圍關聯表)
RoleRightArea rra = new RoleRightArea();
for (int i = 0; i < areaIds.length; i++) {
if (areaIds[i] != null && !areaIds[i].equals("")) {
int areaId = Integer.parseInt(areaIds[i]);
// 根據節點ID查找子節點(只查找部門)
List treeviews = treeViewMgr.getSubDeptByParentId(areaId);
// 判斷是否有子節點,角色權限數據范圍關聯表只保存葉子部門節點
if (treeviews.size() == 0) {
// 設值
rra.setRoleRightsId(roleRightsId);
rra.setTreeviewId(areaId);
// 調用Hibernate DAO保存
roleRightAreaDAO.save(rra);
}
}
}
}
public void saveThreeObjRelation(int id, int rightId, String dataAreaIds,
boolean isNew,String reelection) {
log.debug("數據范圍是: " + dataAreaIds);
String[] areaIds = dataAreaIds.split(",");
log.debug("拆分后的數據范圍是: " + areaIds.length);
int roleRightsId;
// 數據庫里沒有，新增 hrw 2008-12-20 modify
// 實例化一個新對象(崗位權限關聯表)
if (isNew) {
RoleRights pr = new RoleRights();
// 設值
log.debug("id= " + id);
log.debug("rightId= " + rightId);
pr.setRoleId(id);
pr.setRightsId(rightId);
// 調用Hibernate DAO保存
// hrw 2008-12-18 modify
try {
roleRightsDAO.save(pr);
} catch (RuntimeException re) {
log.error(re);
throw new SystemException(Constants.SYSTEMEXCEPTION);
}
roleRightsId = pr.getId();
} else {
roleRightsId = id;// 不是新增的，id為功能權限id。
}
// end
// 獲取最大ID,也就是新插入的記錄ID
// int positionRightsId = positionRightsDAO.getMaxId();
// 2008-12-20 hrw modify
// end
log.debug("roleRightsId" + roleRightsId);
// 實例化一個新對象(崗位權限數據范圍關聯表)
// PositionRightsArea pra = new PositionRightsArea();
List<RoleRightArea> praList = new ArrayList<RoleRightArea>();
for (int i = 0; i < areaIds.length; i++) {
if (areaIds[i] != null && !areaIds[i].equals("")) {
int areaId = Integer.parseInt(areaIds[i]);
RoleRightArea praTmp = new RoleRightArea();
praTmp.setTreeviewId(areaId);
praTmp.setRoleRightsId(roleRightsId);
praList.add(praTmp);
// hrw 2008-12-18 modify 部門和崗位都保存，只有崗位才有效
// //根據節點ID查找子節點(只查找部門)
// List treeviews = treeViewMgr.getSubDeptByParentId(areaId);
// //判斷是否有子節點,崗位權限數據范圍關聯表只保存葉子部門節點
// if(treeviews.size()==0){
// //設值
// pra.setPositionRightsId(positionRightsId);
// pra.setTreeviewId(areaId);
// //調用Hibernate DAO保存
// positionRightsAreaDAO.save(pra);
// }
// 根據節點ID查找子節點(只查找部門)
// List treeviews = treeViewMgr.getSubDeptByParentId(areaId);
// 判斷是否有子節點,崗位權限數據范圍關聯表只保存葉子部門節點
// if(treeviews.size()==0){
// 設值
// hrw 2008 12-20 modify 數據庫里沒有的才新增進去。
// List<PositionRightsArea> praList = positionRightsAreaDAO
// .findByTreeviewId(areaId);
// if (praList.size() <= 0) {
// pra.setPositionRightsId(positionRightsId);
// pra.setTreeviewId(areaId);
// // 調用Hibernate DAO保存
// positionRightsAreaDAO.save(pra);
// }
// }
// modify end
}
}
log.debug("praList size : " + praList.size());
if (praList.size() > 0 || "y".equals(reelection)) {
try {
List<RoleRightArea> oldPra = new ArrayList<RoleRightArea>();
// List<PositionRightsArea> unchangedPra = new
// ArrayList<PositionRightsArea>();
oldPra = roleRightAreaDAO.findByRoleRightsId(roleRightsId);
log.debug("oldPra size 1: " + oldPra.size());
authorizationMgr.recombinationPra(praList, oldPra,
Constants.ROLE_FALG);
log.debug("oldPra size 2: " + oldPra.size());
// log.debug("unchangedPra size: " + unchangedPra.size());
log.debug("praList size : " + praList.size());
for (int i = 0; i < praList.size(); i++) {
// 調用Hibernate DAO保存
roleRightAreaDAO.save(praList.get(i));
}
for (int i = 0; i < oldPra.size(); i++) {
roleRightAreaDAO.delete(oldPra.get(i));
}
} catch (RuntimeException re) {
log.error(re);
throw new SystemException(Constants.SYSTEMEXCEPTION);
}
}
}
public void save(Role role) {
roleDAO.save(role);
}
/**
* 判斷角色是否已存在系統中
*
* @param String
* roleName
* @return boolean
*/
public boolean isExistByRoleName(String roleName) {
boolean result = false;
List<Role> roles = roleDAO.findByRoleName(roleName);
if (roles.size() > 0) {
result = true;
}
return result;
}
/**
* 根據角色ID判斷角色是否已有關聯
*
* @param int
* roleId
* @return boolean
*/
public boolean hasRelation(int roleId) {
boolean result = false;
List<UserRole> ur = userRoleDAO.findByRoleId(roleId);
if (ur.size() > 0) {
result = true;
}
List<RoleRights> rr = roleRightsDAO.findByRoleId(roleId);
if (rr.size() > 0) {
result = true;
}
return result;
}
public UserRoleDAO getUserRoleDAO() {
return userRoleDAO;
}
public void setUserRoleDAO(UserRoleDAO userRoleDAO) {
this.userRoleDAO = userRoleDAO;
}
/**
* 根據角色ID刪除其關聯信息
*/
public void delRoleRelation(Integer roleId) {
// 刪除用戶角色信息
List<UserRole> ur = userRoleDAO.findByRoleId(roleId);
for (int i = 0; i < ur.size(); i++) {
userRoleDAO.delete(ur.get(i));
}
List<RoleRights> rr = roleRightsDAO.findByRoleId(roleId);
for (int i = 0; i < rr.size(); i++) {
// 刪除角色權限數據范圍信息
List<RoleRightArea> rra = roleRightAreaDAO.findByRoleRightsId(rr
.get(i).getId());
for (int j = 0; j < rra.size(); j++) {
roleRightAreaDAO.delete(rra.get(i));
}
// 刪除角色權限信息
roleRightsDAO.delete(rr.get(i));
}
}
/**
* 2008-12-24 hrw add 根據角色IDs刪除其關聯信息 返回已有用戶的角色，角色已分配給用戶的不能刪除。
*/
public String delRoleRelation(String[] roleIds) {
StringBuffer roleId_userRole = new StringBuffer();
List<Integer> roleId_del = new ArrayList<Integer>();
try {
for (int i = 0; i < roleIds.length; i++) {
if (roleIds[i] != null && !"".equals(roleIds[i])) {
// 取用戶角色信息
List ur = userRoleDAO.findByRoleId(Integer
.parseInt(roleIds[i]));
if (ur.size() > 0) {
roleId_userRole.append(roleIds[i] + ",");
} else {
roleId_del.add(Integer.parseInt(roleIds[i]));
}
}
}
// 取角色權限信息
log.debug("取角色權限信息");
List rr = utilDao.findByIds(DataBaseTableName.RoleRights, "roleId",
roleId_del);
List rrIds = new ArrayList();
for (int i = 0; i < rr.size(); i++) {
rrIds.add(((RoleRights) rr.get(i)).getId());
}
log.debug("取角色權限數據范圍信息");
// 取角色權限數據范圍信息
List rra = utilDao.findByIds(DataBaseTableName.RoleRightArea,
"roleRightsId", rrIds);
log.debug("刪除角色權限數據范圍信息");
log.debug("rra : " + rra);
// 刪除角色權限數據范圍信息
if (rra != null) {
utilDao.deleteAll(rra);
}
// 刪除角色權限信息
if (rr != null) {
utilDao.deleteAll(rr);
}
// 取角色
List roles = utilDao.findByIds(DataBaseTableName.Role, "id",
roleId_del);
// 刪除角色
if (roles != null) {
utilDao.deleteAll(roles);
}
log.debug("完成");
} catch (RuntimeException re) {
log.error(re);
throw new SystemException(Constants.SYSTEMEXCEPTION);
}
return roleId_userRole.toString();
}
public static List<Role> findRolesByUserId(int userId) {
List<Role> roles = userRoleDAO.findRolesByUserId(userId);
return roles;
}
public void delete(Role r) {
roleDAO.delete(r);
}
public List<Rights> getAllRightsByRoleId(int roleId) {
List<Rights> rights = roleRightsDAO.getRightsEntityByRoleId(roleId);
return rights;
}
public List<UserRole> findByUserId(Integer id) {
List<UserRole> ur = userRoleDAO.findByUserId(id);
return ur;
}
public void delUserRoleByUserId(int userId) {
userRoleDAO.delUserRoleByUserId(userId);
}
public void saveUserRole(UserRole ur) {
userRoleDAO.save(ur);
}
/**
* 設置用戶的權限
*/
@SuppressWarnings("unchecked")
public void setRole(String[] roles, List userIdList) {
try {
for (int j = 0; j < userIdList.size(); j++) {
// 刪除用戶的所有角色
userRoleDAO.delUserRoleByUserId(Integer.parseInt(userIdList
.get(j).toString()));
for (int i = 0; i < roles.length; i++) {
UserRole ur = new UserRole();
ur
.setUserId(Integer.parseInt(userIdList.get(j)
.toString()));
ur.setRoleId(Integer.parseInt(roles[i]));
userRoleDAO.save(ur);
}
}
} catch (RuntimeException re) {
log.error(re);
throw new SystemException(Constants.SYSTEMEXCEPTION);
}
}
}
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -