rolemgrimpl.java

基于Sturts+Spring+Hibernate的一个高级销售管理系统。内容丰富

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

	}
}