authorizationmgrimpl.java

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

				praList.add(pra);
			}
		}
		return praList;
	}

	/**
	 * 生成UserRightsArea
	 */
	public List<UserRightsArea> conversionUserRightsArea(String[] dataArea) {
		List<UserRightsArea> praList = new ArrayList<UserRightsArea>();
		for (int i = 0; i < dataArea.length; i++) {
			if (dataArea[i] != null && !"".equals(dataArea[i])) {
				UserRightsArea pra = new UserRightsArea();
				pra.setTreeviewId(Integer.parseInt(dataArea[i]));
				praList.add(pra);
			}
		}
		return praList;
	}

	/**
	 * 传进pra1,pra2进行重组，pra1为新的数据，pra2为数据库里有的数据，重组后，pra1为要新增到数据库里的新数据，pra2为数据库要删除的
	 * 数据。
	 */
	@SuppressWarnings("unchecked")
	public List recombinationPr(List pra1, List pra2, int flag) {
		logger.debug("pra2 : " + pra2.size());
		List oldPra = new ArrayList();
		List pra1Tmp = new ArrayList();
		for (int i = 0; i < pra1.size(); i++) {
			boolean falg = false;
			for (int j = 0; j < pra2.size(); j++) {
				int pra1Id = 0;
				int pra2Id = 0;
				if (flag == Constants.POSITION_FLAG) {
					pra1Id = ((PositionRights) pra1.get(i)).getRightsId();
					pra2Id = ((PositionRights) pra2.get(j)).getRightsId();
				}
				if (flag == Constants.ROLE_FALG) {
					pra1Id = ((RoleRights) pra1.get(i)).getRightsId();
					pra2Id = ((RoleRights) pra2.get(j)).getRightsId();
				}
				// 2009-01-17 add
				if (flag == Constants.USER_RIGHTS_FALG) {
					pra1Id = ((UserRights) pra1.get(i)).getRightsId();
					pra2Id = ((UserRights) pra2.get(j)).getRightsId();
				}
				// end add
				logger.debug("pra1 id : " + pra1Id);
				logger.debug("pra2 id : " + pra2Id);
				if (pra1Id == pra2Id) {// 删除掉相同的
					logger.debug("相同");
					oldPra.add(pra2.get(j));
					// pra1.remove(pra1.get(i));
					pra2.remove(pra2.get(j));
					falg = true;
					break;
				}
			}
			if (!falg) {// 数据库里没有的
				pra1Tmp.add(pra1.get(i));
			}
		}
		pra1.removeAll(pra1);
		for (int i = 0; i < pra1Tmp.size(); i++) {
			pra1.add(pra1Tmp.get(i));
		}
		logger.debug("pra1Tmp : " + pra1Tmp.size());
		logger.debug("par1 : " + pra1.size());
		return oldPra;
	}

	/**
	 * 传进pra1,pra2进行重组，pra1为新的数据，pra2为数据库里有的数据，重组后，pra1为要新增到数据库里的新数据，pra2为数据库要删除的
	 * 数据。
	 */
	@SuppressWarnings("unchecked")
	public List recombinationPra(List pra1, List pra2, int flag) {
		List oldPra = new ArrayList();
		List pra1Tmp = new ArrayList();
		for (int i = 0; i < pra1.size(); i++) {
			boolean falg = false;
			for (int j = 0; j < pra2.size(); j++) {
				int tid1 = 0;
				int tid2 = 0;
				if (flag == Constants.POSITION_FLAG) {
					tid1 = ((PositionRightsArea) pra1.get(i)).getTreeviewId();
					tid2 = ((PositionRightsArea) pra2.get(j)).getTreeviewId();
				}
				if (flag == Constants.ROLE_FALG) {
					tid1 = ((RoleRightArea) pra1.get(i)).getTreeviewId();
					tid2 = ((RoleRightArea) pra2.get(j)).getTreeviewId();
				}
				// 2009-01-17 add
				if (flag == Constants.USER_RIGHTS_FALG) {
					tid1 = ((UserRightsArea) pra1.get(i)).getTreeviewId();
					tid2 = ((UserRightsArea) pra2.get(j)).getTreeviewId();
				}
				// end add
				if (tid1 == tid2) {// 删除掉相同的
					oldPra.add(pra2.get(j));
					// pra1.remove(pra1.get(i));
					pra2.remove(pra2.get(j));
					falg = true;
					break;
				}
			}
			if (!falg) {// 数据库里没有的
				pra1Tmp.add(pra1.get(i));
			}
		}
		pra1.removeAll(pra1);
		for (int i = 0; i < pra1Tmp.size(); i++) {
			pra1.add(pra1Tmp.get(i));
		}
		return oldPra;
	}

	public String[] dellSameDataRightsArea(String[] areas) {
		StringBuffer areaSrc = new StringBuffer();
		for (int i = 0; i < areas.length; i++) {
			for (int j = i + 1; j < areas.length; j++) {
				if (areas[i] == areas[j]) {
					areas[j] = null;
				}
			}
		}
		for (int i = 0; i < areas.length; i++) {
			if (areas[i] != null && !"".equals(areas[i])) {
				areaSrc.append("," + areas[i]);
			}
		}
		return areaSrc.toString().split(",");
	}

	// public void authorizationUserRights(int userId, String useScheme,
	// String[] rightIds, int rightsFlag, HttpServletRequest request) {
	// boolean isSuccessfull = true;
	// /*
	// * 获取授权对象所有ID,因为授权对象有可能是部门或整个公司, 而岗位权限关联表里只存岗位,所以如果是部门就要遍历授权对象的下级对象
	// * 再把这些最终对象(岗位)存放到 treeViews 里
	// */
	//
	// if (rightIds != null) {// 从页面取到的rightIds有可能为空
	// if (rightsFlag == Constants.RIGHTS_POSITION_FLAG) {
	// List<UserRights> userRightsNList = new ArrayList<UserRights>();
	// for (int i = 0; i < rightIds.length; i++) {
	// String rid = rightIds[i];
	// UserRights prights = new UserRights();
	// prights.setRightsId(Integer.parseInt(rid));
	// userRightsNList.add(prights);
	// }
	// logger.debug("userRightsNList 1 : " + userRightsNList.size());
	// // 对功能
	// for (int i = 0; i < userRightsNList.size(); i++) {// 新增新的功能权限
	// int rightId = userRightsNList.get(i).getRightsId();
	// logger.debug("权限ID: " + rightId);
	//
	// String dataAreaIds = "";// 数据范围对象
	// String dataAreaId_pid = "";// 子模块全局数据范围对象ID
	// String dataAreaId_pidValue = "";
	// logger.debug("逐步授权 ");
	// /*
	// * 在rightTree.js里，每个树节点都挂一下隐藏域，隐藏域属性ID,name均为 节点ID + "_area"
	// * 字符串, 隐藏域存储数据范围页面返回的部门节点ID集合组成的字符串
	// */
	// // dataAreaIds = request.getParameter(rid + "_area");//
	// // 数据范围对象
	// dataAreaIds = request.getParameter(rightId + "_area");// 数据范围对象
	// logger.debug("dataAreaIds : " + dataAreaIds);
	// dataAreaId_pid = request.getParameter(rightId + "_pid");//
	// 取页面子模块数据全局范围Id。
	// logger.debug("dataAreaId_pid : " + dataAreaId_pid);
	// dataAreaId_pidValue = request.getParameter(dataAreaId_pid
	// + "_area");// 取页面子模块数据全局范围
	// logger
	// .debug("dataAreaId_pidValue : "
	// + dataAreaId_pidValue);
	// String dataAreaSelectedFlag = request.getParameter(rightId
	// + "_selected");// 功能权限的数据范围是否有被重新设置过。
	// // 先确定是否有先设整体模块的全局数据范围，再处理子模块的全局数据范围。
	// String allAreas = request.getParameter("_area");
	// logger.debug("allAreas : " + allAreas);
	// String pDataAreaSelectedFlag = request
	// .getParameter(dataAreaId_pid + "_selected");
	// logger.debug("pDataAreaSelectedFlag : "
	// + pDataAreaSelectedFlag);
	// if (allAreas != null && !"".equals(allAreas)) {
	// if (!"y".equals(pDataAreaSelectedFlag)) {
	// dataAreaId_pidValue = allAreas;
	// }
	// }
	// // dataAreaIds 不能为null
	// if (dataAreaIds == null || "".equals(dataAreaIds)) {
	// dataAreaIds = "";
	// if (dataAreaId_pidValue != null
	// && !"".equals(dataAreaId_pidValue)) {// 功能权限没有选数据范围且子模块有设全局数据权限
	// // 若有设子模志全局的数据范围且该功能权限的数据范围没被重新设置过，默认为被全局设置过，数据范围为全局的和原有的数据范围。
	// // 若功能权限被重新设置过，以重新设置过为主。
	// if (!"y".equals(dataAreaSelectedFlag)) {
	// dataAreaIds = dataAreaId_pidValue;
	// }
	// }
	// }
	// logger.debug("dataAreaIds : " + dataAreaIds);
	//
	// logger.debug("数据范围ID: " + dataAreaIds);
	// try {
	// /*
	// * 保存授权对象, 权限对象以及数据范围对象三者的关系
	// * 因为对不同授权对象授予的权限对象是一样的,所以先循环权限表,再为每一个授权对象授予同一权限
	// * 每一个隐藏域里存放的数据范围对象ID集合也都是对应一个权限
	// */
	// // 保存授权对象, 权限对象以及数据范围对象三者的关系
	// userRightsMgr.saveThreeObjRelation(userId, rightId,
	// dataAreaIds, true);
	// } catch (SystemException e) {
	// logger.error(e.getMessage());
	// isSuccessfull = false;
	// }
	// }
	// }
	// // }
	// // for (int i = 0; i < prs.size(); i++) {// 删除撤消的功能权限和相关的数据权限
	// // // 删除岗位权限数据范围表信息
	// // positionMgr.deletePositionRightsAreaByPositionRights(prs);
	// // // 删除岗位权限表信息
	// // positionMgr.deletePositionRightsByPositionRights(prs);
	// // }
	// } else {// 如果从页面取到的right为空，说明该岗位没有任何权限，些时删除所有权限
	// // 删除岗位权限数据范围表信息
	// // positionMgr.deletePositionRightsAreaByPositionRights(prs);
	// // 删除岗位权限表信息
	// // positionMgr.deletePositionRightsByPositionRights(prs);
	//
	// }
	// if (isSuccessfull) {// 授权成功
	// // 获取当前用户信息
	// User user = (User) request.getSession().getAttribute(
	// Constants.SESSION_USER);
	// // 获取全局会话
	// ServletContext application = request.getSession()
	// .getServletContext();
	// // 获取用户信息
	// Map userInfo = (Map) application
	// .getAttribute(SystemConstant.APPLICATION_USER_INFO);
	// if (userInfo != null) {
	// logger.debug("userInfo: " + userInfo + " userInfo.size: "
	// + userInfo.size());
	// List<Rights> rights = userRightsMgr.getUserRightsDao()
	// .findByUserId(userId);
	//
	// // 遍历存放用户session的Map对象
	// for (Object o : userInfo.keySet()) {
	// Integer userId1 = (Integer) o;
	// logger.debug("key: " + userId1);
	//
	// // 不是本人的ID(管理员)
	// if (!userId1.equals(user.getId())) {
	// // 获取Session
	// HttpSession session = (HttpSession) userInfo.get(o);
	// logger.debug("session: " + session);
	// User u = (User) session
	// .getAttribute(Constants.SESSION_USER);
	// logger.debug("user: " + u);
	// // 设入用户权限是否被修改的值
	// session.setAttribute(
	// SystemConstant.SESSION_RIGHTS_IS_UPDATED, true);
	// // 设入岗位所拥有的权限集合
	// session.setAttribute(SystemConstant.SESSION_RIGHTS,
	// rights);
	//
	// }
	// }
	// }
	// }
	// }

	@SuppressWarnings("unchecked")
	public void authorizationUserRights(int userId, String useScheme,
			String[] rightIds, int rightsFlag, int positionId,
			HttpServletRequest request) {
		boolean isSuccessfull = true;
		try {
			UserRightsFlag userRightsFlag = userRightsMgr
					.getUserRightsFlagDAO().findById(userId);
			if (userRightsFlag == null) {
				userRightsFlag = new UserRightsFlag();
				userRightsFlag.setUserId(userId);
				if (rightsFlag == Constants.RIGHTS_POSITION_FLAG) {
					userRightsFlag.setFlag(Constants.RIGHTS_USER_FLAG);
				} else {
					userRightsFlag.setFlag(rightsFlag);
				}
				userRightsMgr.getUserRightsFlagDAO().save(userRightsFlag);
			} else {
				if (userRightsFlag.getFlag().intValue() != Constants.RIGHTS_USER_FLAG) {
					userRightsFlag.setFlag(Constants.RIGHTS_USER_FLAG);
					userRightsMgr.getUserRightsFlagDAO().attachDirty(
							userRightsFlag);
				}
			}
		} catch (RuntimeException re) {
			logger.error(re);
			throw new SystemException(Constants.SYSTEMEXCEPTION);
		}
		List<UserRights> urs = new ArrayList<UserRights>();

		// 取角色权限对象集合
		try {
			urs = userRightsMgr.getUserRightsDao().findByUserId(userId);
		} catch (RuntimeException re) {
			throw new SystemException(Constants.SYSTEMEXCEPTION);
		}
		logger.debug("用户权限对象集合的大小是: " + urs.size());
		// 不预先删除功能权限和数据权限，只有功能权限和数据权限有改动才修改数据库。
		if (rightIds != null) {// 从页面取到的rightIds有可能为空
			List<UserRights> prNewList = new ArrayList<UserRights>();
			for (int i = 0; i < rightIds.length; i++) {
				String rid = rightIds[i];
				UserRights prights = new UserRights();
				prights.setRightsId(Integer.parseInt(rid));
				prNewList.add(prights);
			}
			logger.debug("prNewList 1 : " + prNewList.size());
			// 对功能
			List<UserRights> oldPra = recombinationPr(prNewList, urs,