positionmgrimpl.java

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

package com.yuanchung.sales.service.admin.position.impl;

import java.util.ArrayList;
import java.util.List;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

import org.apache.log4j.Logger;

import com.yuanchung.organize.treeview.TreeViewMgr;
import com.yuanchung.sales.constants.SystemConstant;
import com.yuanchung.sales.dao.admin.RightsDAO;
import com.yuanchung.sales.dao.admin.position.PositionRightsAreaDAO;
import com.yuanchung.sales.dao.admin.position.PositionRightsDAO;
import com.yuanchung.sales.exception.SystemException;
import com.yuanchung.sales.model.Position;
import com.yuanchung.sales.model.Treeview;
import com.yuanchung.sales.model.admin.Rights;
import com.yuanchung.sales.model.admin.position.PositionRights;
import com.yuanchung.sales.model.admin.position.PositionRightsArea;
import com.yuanchung.sales.model.user.User;
import com.yuanchung.sales.service.admin.authorization.AuthorizationMgr;
import com.yuanchung.sales.service.admin.position.PositionMgr;
import com.yuanchung.sales.service.user.impl.UserMgrImpl;
import com.yuanchung.sales.util.Constants;

public class PositionMgrImpl implements PositionMgr {

	private Logger log = Logger.getLogger(PositionMgrImpl.class);
	private static PositionRightsDAO positionRightsDAO;
	private static RightsDAO rightsDAO;
	private static PositionRightsAreaDAO positionRightsAreaDAO;
	private AuthorizationMgr authorizationMgr;
	private TreeViewMgr treeViewMgr;

	public TreeViewMgr getTreeViewMgr() {
		return treeViewMgr;
	}

	public void setTreeViewMgr(TreeViewMgr treeViewMgr) {
		this.treeViewMgr = treeViewMgr;
	}

	public PositionRightsAreaDAO getPositionRightsAreaDAO() {
		return positionRightsAreaDAO;
	}

	public void setPositionRightsAreaDAO(
			PositionRightsAreaDAO positionRightsAreaDAO) {
		this.positionRightsAreaDAO = positionRightsAreaDAO;
	}

	public PositionRightsDAO getPositionRightsDAO() {
		return positionRightsDAO;
	}

	public void setPositionRightsDAO(PositionRightsDAO positionRightsDAO) {
		this.positionRightsDAO = positionRightsDAO;
	}

	/**
	 * 保存授权对象, 权限对象以及数据范围对象三者的关系
	 * 
	 * @param int
	 *            positionId 岗位ID
	 * @param int
	 *            rightId 权限ID
	 * @param String
	 *            dataAreaIds 数据范围域字符串
	 * @throws SystemException
	 */
	public void saveThreeObjRelation(int positionId, int rightId,
			String dataAreaIds) throws SystemException {
		log.debug("数据范围是: " + dataAreaIds);
		String[] areaIds = dataAreaIds.split(",");
		log.debug("拆分后的数据范围是: " + areaIds.length);
		// 实例化一个新对象(岗位权限关联表)
		PositionRights pr = new PositionRights();
		// 设值
		log.debug("positionId= " + positionId);
		log.debug("rightId= " + rightId);
		pr.setTreeviewId(positionId);
		pr.setRightsId(rightId);
		// 调用Hibernate DAO保存
		// hrw 2008-12-18 modify
		positionRightsDAO.save(pr);

		// 获取最大ID,也就是新插入的记录ID
		int positionRightsId = positionRightsDAO.getMaxId();
		log.debug("positionRightsId" + positionRightsId);
		// 实例化一个新对象(岗位权限数据范围关联表)
		PositionRightsArea pra = new PositionRightsArea();
		for (int i = 0; i < areaIds.length; i++) {
			if (areaIds[i] != null && !areaIds[i].equals("")) {
				int areaId = Integer.parseInt(areaIds[i]);
				// 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){
				// 设值
				pra.setPositionRightsId(positionRightsId);
				pra.setTreeviewId(areaId);
				// 调用Hibernate DAO保存
				positionRightsAreaDAO.save(pra);
				// }

				// modify end
			}
		}
	}

	/**
	 * 对没有重新选的数据权限不做任何处理
	 */
	@SuppressWarnings("unchecked")
	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 positionRightsId;
		// 数据库里没有，新增 hrw 2008-12-20 modify
		// 实例化一个新对象(岗位权限关联表)
		if (isNew) {
			PositionRights pr = new PositionRights();
			// 设值
			log.debug("id= " + id);
			log.debug("rightId= " + rightId);
			pr.setTreeviewId(id);
			pr.setRightsId(rightId);
			// 调用Hibernate DAO保存
			// hrw 2008-12-18 modify
			try {
				positionRightsDAO.save(pr);
			} catch (RuntimeException re) {
				log.error(re);
				throw new SystemException(Constants.SYSTEMEXCEPTION);
			}
			positionRightsId = pr.getId();
		} else {
			positionRightsId = id;// 不是新增的，id为功能权限id。
		}
		// end

		// 获取最大ID,也就是新插入的记录ID
		// int positionRightsId = positionRightsDAO.getMaxId();
		// 2008-12-20 hrw modify
		// end
		log.debug("positionRightsId" + positionRightsId);
		// 实例化一个新对象(岗位权限数据范围关联表)
		// PositionRightsArea pra = new PositionRightsArea();
		List<PositionRightsArea> praList = new ArrayList<PositionRightsArea>();
		for (int i = 0; i < areaIds.length; i++) {
			if (areaIds[i] != null && !areaIds[i].equals("")) {
				int areaId = Integer.parseInt(areaIds[i]);
				PositionRightsArea praTmp = new PositionRightsArea();
				praTmp.setTreeviewId(areaId);
				praTmp.setPositionRightsId(positionRightsId);
				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<PositionRightsArea> oldPra = new ArrayList<PositionRightsArea>();
				// List<PositionRightsArea> unchangedPra = new
				// ArrayList<PositionRightsArea>();
				oldPra = positionRightsAreaDAO
						.findByPositionRightsId(positionRightsId);
				log.debug("oldPra size 1: " + oldPra.size());
				authorizationMgr.recombinationPra(praList, oldPra,
						Constants.POSITION_FLAG);
				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保存
					positionRightsAreaDAO.save(praList.get(i));
				}
				for (int i = 0; i < oldPra.size(); i++) {
					positionRightsAreaDAO.delete(oldPra.get(i));
				}
			} catch (RuntimeException re) {
				log.error(re);
				throw new SystemException(Constants.SYSTEMEXCEPTION);
			}
		}
	}

	/**
	 * 根据岗位ID,获取所有功能权限
	 * 
	 * @param positionId
	 *            岗位ID
	 * @return List<PositionRights> 岗位权限对象集合
	 */
	public List<PositionRights> getRightsByPositionId(int positionId) {
		List<PositionRights> positionRights = positionRightsDAO
				.getRightsByPositionId(positionId);
		return positionRights;
	}

	/**
	 * 根据权限ID岗位ID,获取数据范围
	 * 
	 * @param rightsID权限ID
	 *            positionId 岗位ID
	 * @return List<PositionRightsArea> 岗位权限数据范围对象集合
	 */
	public List<PositionRightsArea> getDataAreaByRidPid(int rightsId,
			int positionId) {
		try {
			List<PositionRightsArea> positionRightsArea = positionRightsDAO
					.getRightsByPositionId(rightsId, positionId);
			return positionRightsArea;
		} catch (RuntimeException re) {
			log.error(re);
			throw new SystemException(Constants.SYSTEMEXCEPTION);
		}
	}

	/**
	 * 根据岗位ID集合获取岗位权限关联表里的信息
	 * 
	 * @param List
	 *            positionIds
	 * @return List<PositionRights> positionRights
	 */
	public List<PositionRights> findByPositions(List<Treeview> positions) {
		List<PositionRights> positionRights = new ArrayList();
		// 获取所有岗位ID
		List positionIds = new ArrayList();
		for (int i = 0; i < positions.size(); i++) {
			positionIds.add(positions.get(i).getId());
		}
		for (int i = 0; i < positionIds.size(); i++) {
			Integer treeviewId = (Integer) positionIds.get(i);
			List<PositionRights> pr = positionRightsDAO
					.findByTreeviewId(treeviewId);
			positionRights.addAll(pr);// 放在同一个集合里
		}
		return positionRights;
	}

	/**
	 * 根据岗位权限集合删除岗位权限数据范围关联表里的信息
	 * 
	 * @param List
	 *            <PositionRights>
	 */
	public void deletePositionRightsAreaByPositionRights(
			List<PositionRights> prs) {
		for (int i = 0; i < prs.size(); i++) {
			// 先根据岗位权限ID获取对象集合,再遍历对象集合进行删除
			log.debug("岗位权限ID是: " + prs.get(i).getId());
			List<PositionRightsArea> positionRightAreas = positionRightsAreaDAO
					.findByPositionRightsId(prs.get(i).getId());
			log.debug("岗位权限的数据范围大小: " + positionRightAreas.size());
			for (int j = 0; j < positionRightAreas.size(); j++) {
				positionRightsAreaDAO.delete(positionRightAreas.get(j));
			}
		}
	}

	/**
	 * 根据岗位权限集合删除岗位权限关联表里的信息
	 * 
	 * @param List
	 *            positionIds
	 */
	public void deletePositionRightsByPositionRights(List<PositionRights> prs) {
		for (int i = 0; i < prs.size(); i++) {
			PositionRights positionRight = prs.get(i);
			positionRightsDAO.delete(positionRight);
		}
	}

	/**
	 * 根据岗位ID获取功能权限实体对象
	 * 
	 * @param Integer
	 *            id
	 * @return List<Rights> rights
	 */
	public List<Rights> getAllRightsByPositionId(Integer id) {
		List<Rights> rights = positionRightsDAO.getRightsEntityByPositionId(id);

		return rights;
	}

	/**
	 * 根据操作用户与权限名称获取构造数据范围底下的所有用户 最终获取userId字符数组
	 * 
	 * @param User
	 *            user
	 * @param String
	 *            rightsName
	 * @return int[] userIds
	 * @throws SystemException
	 */
	public static int[] getCallableUserIds(HttpServletRequest request,
			String rightsName) throws SystemException {
		HttpSession session = request.getSession();
		User user = (User) session.getAttribute(Constants.SESSION_USER);
		int[] userIds = (int[]) session
				.getAttribute(SystemConstant.SESSION_USERIDS);
		if (userIds == null) {
			// 实例化一个存储用户信息集合
			List<User> allUsers = new ArrayList();
			// 获取岗位对象ID
			int positionId = 0;
			if (user != null) {
				positionId = user.getTreeview().getId();
			}
			int rightsId = 0;
			// 获取权限对象ID
			List<Rights> right = rightsDAO.findByRightsName(rightsName);
			if (right.size() > 0) {
				rightsId = right.get(0).getId();
			}
			// 获取岗位权限关联对象ID
			PositionRights pr = positionRightsDAO.findByPositionIdRightsId(
					positionId, rightsId);
			int positionRightsId = 0;
			if (pr != null) {
				positionRightsId = pr.getId();
			}

			// 获取岗位权限数据范围关联对象集合
			List<PositionRightsArea> praList = positionRightsAreaDAO
					.findByPositionRightsId(positionRightsId);
			for (int i = 0; i < praList.size(); i++) {
				// 获取部门底下所有岗位 isLeader = 1
				List<Treeview> tr = new ArrayList();
				tr = TreeViewMgr.findChildIdsByParentId(tr, praList.get(i)
						.getTreeviewId());
				// 实例化一个存储用户信息集合
				List<User> users = new ArrayList();
				// 遍历岗位获取用户对象
				for (int j = 0; j < tr.size(); j++) {
					if (!tr.get(j).getIsLeader().equals(0)) {
						List<User> us = UserMgrImpl.findByTreeviewId(tr.get(j)
								.getId());
						// 放入大集合里
						users.addAll(us);
					}
				}
				// 放入最大集合里
				allUsers.addAll(users);
			}

			int[] tempUserIds = new int[allUsers.size()];
			for (int i = 0; i < allUsers.size(); i++) {
				tempUserIds[i] = allUsers.get(i).getId();
			}
			userIds = tempUserIds;
		}
		return userIds;
	}

	public AuthorizationMgr getAuthorizationMgr() {
		return authorizationMgr;
	}

	public void setAuthorizationMgr(AuthorizationMgr authorizationMgr) {
		this.authorizationMgr = authorizationMgr;
	}

}