/**
    * Copyright By Grandsoft Company Limited.  
    * 2012-3-16 下午02:28:13
    */
   package gboat2.web.business.impl;
   
   import gboat2.base.core.cache.ICacheService;
   import gboat2.base.core.dao.QuerySupport;
   import gboat2.base.core.service.BaseService;
  import gboat2.base.bridge.exception.DefaultGboatNestedException;
  import gboat2.web.Constants;
  import gboat2.web.business.IAuthorityBusiness;
  import gboat2.web.business.IDataLevelAuthorityBusiness;
  import gboat2.web.business.IGroupBusiness;
  import gboat2.web.business.IOperationBusiness;
  import gboat2.web.business.IResourceBusiness;
  import gboat2.web.business.IRoleBusiness;
  import gboat2.web.model.Authority;
  import gboat2.web.model.AuthorityDataLevelResourceVO;
  import gboat2.web.model.AuthorityOperationResourceVO;
  import gboat2.web.model.AuthorityOperationVO;
  import gboat2.web.model.AuthorityResourceVO;
  import gboat2.web.model.DataLevelAuthority;
  import gboat2.web.model.Group;
  import gboat2.web.model.Operation;
  import gboat2.web.model.Resource;
  import gboat2.web.model.Role;
  
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.commons.lang3.StringUtils;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.stereotype.Service;
  import org.springframework.transaction.annotation.Transactional;
  
  /**
   * 授权操作
   * @author wangsr
   * @modified by sunpf 2012-4-15
   * @since jdk1.6
   * @date 2012-3-16
   */
  @Transactional
  @Service
  public class AuthorityBusinessImpl extends BaseService implements IAuthorityBusiness {
  
  	@Autowired
  	private IOperationBusiness operaBusi;
  
  	@Autowired
  	private IResourceBusiness resourceBusi;
  
  	@Autowired
  	private IDataLevelAuthorityBusiness dataLevelAuthorityBusi;
  
  	@Autowired
  	private IGroupBusiness groupBusi;
  
  	@Autowired
  	private IRoleBusiness roleBusi;
  
  	@Autowired
  	private ICacheService cacheSer;
  
  	//private Logger logger = LoggerFactory.getLogger(AuthorityBusinessImpl.class.getName());
  	
  
  	@Override
  	public boolean setAuthority(String authForId, String resId) {
  		/**
  		 * 添加模块的权限:
  		 * 1.添加模块的全部权限
  		 * 2.添加其父模块的访问权限
  		 * 3.添加其子模块的全部权限
  		 */
  		if (StringUtils.isEmpty(authForId) || StringUtils.isEmpty(resId)) {
  			return false;
  		}
  		Resource res = (Resource) super.get(Resource.class, resId);
  		this.addResourceAuthority(authForId, res);
  		this.addResourceAuthorityForParent(authForId, res);
  		this.addResourceAuthorityForChild(authForId, res);
  		return true;
  	}
  
  	@Override
  	public boolean deleteAuthority(String authForId, String resId, String systemId) {
  		if (StringUtils.isEmpty(authForId) || StringUtils.isEmpty(resId) || StringUtils.isEmpty(systemId)) {
  			return false;
  		}
  		/**【第一次定制用户组权限的时候，初始化用户组的角色权限】
  		 *当为用户组的角色第一次定制权限的时候，其实用户组角色的权限还没有分配，
  		 *权限树之所以显示选中状态，那是其角色的权限，参见findResourceForRole方法。
  		 *从角色的权限中为用户组的角色授权authForId格式为"groupId.roleId"
  		 *[用户的定制同用户组中角色定制相同]
  		 */
 		//删除时需要考虑是否为定制，如果是定制则需要copy权限
 		this.cascadeSetAuthAtFirstDel(authForId, resId, systemId);
 		/** 删除授权 start */
 		this.deleteResourceAuthority(authForId, resId);// 删除当前节点
 		this.deleteResourceAuthorityOfChild(authForId, resId);//删除孩子节点
 		/** 删除授权 end */
 		return true;
 	}
 
 	@Override
 	public boolean setOperationsAuthority(String authForId, String resId, String operaId) {
 	 	/**
 		 * 设置操作权限分3步
 		 * 1.添加对模块中操作的权限
 		 * 2.如果组中有无效的此操作权限，将其置为有效
 		 */
 		
 		if (StringUtils.isEmpty(authForId) || StringUtils.isEmpty(resId) || StringUtils.isEmpty(operaId)) {
 			return false;
 		}
 		Resource res = (Resource) get(Resource.class, resId);
 		//1.添加对operation的授权
 		this.saveAuthority(authForId, resId, res.getSystemId(), operaId, "1");
 		//2.添加角色对operation的权限，还原组内角色继承的已经失效的权限
 		this.cascadeAuth(true, authForId, resId, operaId);
 		return true;
 	}
 
 	@Override
 	public boolean deleteOperationAuthority(String authForId, String resId, String operaId, String systemId) {
 		if (StringUtils.isEmpty(authForId) || StringUtils.isEmpty(resId) 
 				|| StringUtils.isEmpty(operaId) || StringUtils.isEmpty(systemId)) {
 			return false;
 		}
 
 		// 用户组第一次定制操作权限的时候，首先复制所有的角色权限（继承），再删除要删除的权限
 		//第一次删除的时候需要copy权限
 		this.cascadeSetAuthAtFirstDel(authForId, resId, systemId);
 		//删除操作权限
 		this.deleteOpertionAuthorityBy(authForId, resId, operaId);
 		//在删除角色或组角色操作权限的时候，需要级联设置继承权限为无效
 		this.cascadeAuth(false, authForId, resId, operaId);
 		return true;
 	}
 		
 	@Override
 	public boolean isAuthorityCustomize(String authForId,String systemId){
 		String hql = "select count(authId) from Authority where authForId=:authForId and systemId=:systemId";
 		Map<String, Object> params = new HashMap<String, Object>();
 		params.put("authForId", authForId);
 		params.put("systemId", systemId);
 		List<?> result = super.baseDAO.queryListByHql(hql, params);
 		Long sum = (Long) result.get(0);
 		return sum.longValue() > 0;
 	}
 
 	@Override
 	public List<Authority> findAuthoritiesByAuthForId(String authForId, String systemId) {
 		String[][] params = { { Authority.class.getName() }, { "_authForId", authForId }, { "_systemId", systemId } };
 		return (List<Authority>) super.baseDAO.queryList(params);
 	}
 
 	@Override
 	public List<AuthorityResourceVO> findBrothersAuthorityForResource(String roleId, String resId) {
 		List<AuthorityResourceVO> brothers = null;
 		Resource res = (Resource) super.get(Resource.class, resId);
 		Resource parent = (Resource) super.get(Resource.class, res.getParentId());
 		if (parent != null) {
 			String[][] params = { { AuthorityResourceVO.class.getName() }, { QuerySupport.PARAM_DISTINCT, "true" }, { "_authForId", roleId },
 					{ "_parentId", parent.getResId() }, { "_resId_ne", resId }, { "_useStatus", "1" } };
 			brothers = (List<AuthorityResourceVO>) super.baseDAO.queryList(params);
 		}
 		return brothers;
 	}
 	
 	@Override
 	public List<Operation> findOperationsForResource(String resId) {
 		List<Operation> allOpera = null;
 		allOpera = this.operaBusi.getOperationsByResourceId(resId);
 		return allOpera;
 	}
 
 	@Override
 	public List<AuthorityOperationVO> findOperationsForRole(String resId, String roleId) {
 		List<AuthorityOperationVO> result = null;
 		//_operationId_notnull 支持不存在operation只对Resource的授权（operas为空，则什么也查不到，即没有操作）
 		String[][] params = { { AuthorityOperationVO.class.getName() }, { QuerySupport.PARAM_DISTINCT, "true" }, { "_authForId", roleId },
 				{ "_resId", resId }, { "_operationId_notnull", "true" }, { "_useStatus", "1" } };
 		result = (List<AuthorityOperationVO>) super.baseDAO.queryList(params);
 		return result;
 	}
 
 	@Override
 	public boolean deleteAuthorityByRoleId(String roleId) {
 		String hql = "delete from Authority where authForId=:roleId or authForId like '%." + roleId + "'";
 		Map<String, Object> params = new HashMap<String, Object>();
 		params.put("roleId", roleId);
 		super.baseDAO.deleteByQuery(hql, params);
 		return true;
 	}
 
 	@Override
 	public List<AuthorityResourceVO> getAuthorityByStatus(String status, String systemId) {
 		if (StringUtils.isEmpty(systemId)) {
 			return null;
 		}
 		Map<String, Object> params = new HashMap<String, Object>();
 		params.put(QuerySupport.PARAM_TABLENAME, AuthorityResourceVO.class);
 		params.put("_authForId", status);
 		params.put("_systemId", systemId);
 		params.put("_useStatus", "1");
 		List<AuthorityResourceVO> list = (List<AuthorityResourceVO>) super.query(params);
 		return list;
 	}
 
 	@Override
 	public String findDataLevelForRoleOfGroup(String groupId, String roleId, String resId) {
 		DataLevelAuthority auth = this.dataLevelAuthorityBusi.findDataLevelAuthority(groupId, roleId, resId);
 		if (auth != null) {// 找到则返回定制的级别
 			return auth.getDataLevel();
 		} else {// 没有找到，则返回用户组默认的级别
 			Group group = (Group) this.groupBusi.get(Group.class, groupId);
 			return group.getDefaultDataLevel();
 		}
 	}
 
 	@Override
 	public List<AuthorityOperationVO> findOperationsForRoleOfGroup(String groupId, String roleId, String resId) {
 		String[][] params = { { AuthorityOperationVO.class.getName() }, { QuerySupport.PARAM_DISTINCT, "true" },
 				{ "_authForId", groupId + "." + roleId }, { "_resId", resId }, { "_useStatus", "1" }, { "_operationId_notnull", "true" } };
 		List<AuthorityOperationVO> operations = (List<AuthorityOperationVO>) baseDAO.queryList(params);
 		if (null == operations || 0 == operations.size()) {
 			//判断是否自动继承角色的权限（查看用户组中的该角色是否定制过，定制过则无需继承，因为是他定制的没有操作权限）
 			Resource res = (Resource) super.get(Resource.class, resId);
 			List<Authority> auth = this.findAuthoritiesByAuthForId(groupId + "." + roleId, res.getSystemId());
 			if (auth == null || auth.size() == 0) {
 				// TODO 如果用户定制之后为全部取消的状态，则无法判断是否定制过。此处按没有定制处理
 				// 没有定制过，说明还是初始化的状态，则初始化改角色的所有操作权限
 				operations = this.findOperationsForRole(resId, roleId);
 			}
 		}
 		return operations;
 	}
 
 	@Override
 	public List<AuthorityResourceVO> getTopLevelAuths(String authForId, String systemId) {
 		List<AuthorityResourceVO> auths = this.getAuthsByLevel(authForId, "0", systemId);
 		return auths;
 	}
 
 	@Override
 	public List<AuthorityOperationResourceVO> getAuthorityOperationResource(String authForId, String systemId) {
 		if (StringUtils.isEmpty(systemId)) {
 			return null;
 		}
 		Map<String, Object> params = new HashMap<String, Object>();
 		params.put(QuerySupport.PARAM_TABLENAME, AuthorityOperationResourceVO.class);
 		params.put("_authForId", authForId);
 		params.put("_systemId", systemId);
 		params.put("_useStatus", "1");
 		List<AuthorityOperationResourceVO> list = (List<AuthorityOperationResourceVO>) super.query(params);
 		return list;
 	}
 
 	@Override
 	public List<AuthorityDataLevelResourceVO> getAuthorityDataLevelResource(String groupId, String roleId, String systemId) {
 		if (StringUtils.isEmpty(systemId)) {
 			return null;
 		}
 		Map<String, Object> params = new HashMap<String, Object>();
 		params.put(QuerySupport.PARAM_TABLENAME, AuthorityDataLevelResourceVO.class);
 		params.put("_groupId", groupId);
 		params.put("_systemId", systemId);
 		params.put("_roleId", roleId);
 		List<AuthorityDataLevelResourceVO> list = (List<AuthorityDataLevelResourceVO>) super.query(params);
 		return list;
 	}
 
 	@Override
 	public AuthorityResourceVO findResourceTreeForRoleOfSystem(String roleId, String systemId) {
 		AuthorityResourceVO root = null;
 		root = this.findResourceTreeForRole(roleId, "0", systemId);
 		return root;
 	}
 
 
 	@Override
 	public List<AuthorityResourceVO> getAuthorityResourceByStatus(String authForId, String systemId) {
 		if (StringUtils.isEmpty(systemId)) {
 			return null;
 		}
 		Map<String, Object> params = new HashMap<String, Object>();
 		params.put(QuerySupport.PARAM_TABLENAME, AuthorityResourceVO.class);
 		params.put("_authForId", authForId);
 		params.put("_systemId", systemId);
 		List<AuthorityResourceVO> list = (List<AuthorityResourceVO>) super.query(params);
 		return list;
 	}
 
 	@Override
 	public boolean deleteAuthorityOfCustom(String authForId, String systemId) {
 		String hql = "delete from Authority where systemId='" + systemId + "' and authForId = :authForId";
 		Map<String, Object> params = new HashMap<String, Object>();
 		params.put("authForId", authForId);
 		super.baseDAO.deleteByQuery(hql, params);
 		return true;
 	}
 
 	@Override
 	public boolean setDataLevelAuthority(String groupId, String roleId, String resId, String dataLevel) {
 		return this.dataLevelAuthorityBusi.setDataLevelAuthority(groupId, roleId, resId, dataLevel);
 	}
 
 	@Override
 	public boolean deleteAuthorityByLikeGroupId(String groupId) {
 		String hql = "delete from Authority where authForId like '" + groupId + ".%'";
 		super.baseDAO.deleteByQuery(hql, null);
 		return true;
 	}
 
 	@SuppressWarnings("unchecked")
 	@Override
 	public List<AuthorityResourceVO> getAuthsByLevel(String authForId, String resId, String systemId) {
 		Map<String, Object> queryParams = new HashMap<String, Object>();
 		queryParams.put(QuerySupport.PARAM_TABLENAME, AuthorityResourceVO.class.getName());
 		queryParams.put(QuerySupport.PARAM_DISTINCT, true);
 		queryParams.put(QuerySupport.PARAM_ORDERBY, "dispOrder");
 		queryParams.put("_authForId", authForId);
 		queryParams.put("_parentId", resId);
 		queryParams.put("_useStatus", "1");
 		//过滤以：“##”开头的模块，这些在角色权限树中不显示
 		queryParams.put("_block", "RES_NAME not like '##%'");
 		//如果resId==0,则取得该角色在该系统下的所有顶级模块。（因为parentId==0,没有办法确定系统）
 		//如果resId!=0,则resId的系统就已经确定，无需添加systemId条件
 		if ("0".equals(resId) && systemId != null) {
 			queryParams.put("_systemId", systemId);
 		}
 		List<AuthorityResourceVO> auths = (List<AuthorityResourceVO>) baseDAO.queryList(queryParams);
 		return auths;
 	}
 
 	@Override
 	public AuthorityResourceVO findResourceTreeForRoleOfGroupOfSystem(String authForId, String systemId, boolean useCache) {
 		AuthorityResourceVO root = null;
 		if (useCache) {
 			root = (AuthorityResourceVO) this.cacheSer.get(Constants.MENU_TREE_CACHE_CATALOG, authForId + "-" + systemId);
 			if (null == root) {
 				root = this.findResourceTreeForRoleOfGroup(authForId, "0", systemId);
 				//只缓存完整的权限树，取得时候，截取一部分子树
 				this.cacheSer.put(Constants.MENU_TREE_CACHE_CATALOG, authForId + "-" + systemId, root);
 			}
 		} else {
 			root = this.findResourceTreeForRoleOfGroup(authForId, "0", systemId);
 		}
 		return root;
 	}
 
 	@Override
 	public AuthorityResourceVO findResourceTreeForRoleOfGroupForRes(String authForId, String resId, boolean useCache) {
 		AuthorityResourceVO root = null;
 		Resource res = null;
 		if (StringUtils.isEmpty(resId)) {
 			return root;
 		}
 		if (resId.startsWith("##")) {
 			//此时的resId是resName
 			res = resourceBusi.getResourceByResname(resId);
 		} else {
 			res = (Resource) super.get(Resource.class, resId);
 		}
 		AuthorityResourceVO ret = new AuthorityResourceVO();
 		if (useCache) {
 			root = (AuthorityResourceVO) this.cacheSer.get(Constants.MENU_TREE_CACHE_CATALOG, authForId + "-" + res.getSystemId());
 			if (null == root) {
 				root = this.findResourceTreeForRoleOfGroup(authForId, "0", res.getSystemId());
 				//只缓存完整的权限树，取得时候，截取一部分子树
 				this.cacheSer.put(Constants.MENU_TREE_CACHE_CATALOG, authForId + "-" + res.getSystemId(), root);
 			}
 		} else {
 			root = this.findResourceTreeForRoleOfGroup(authForId, "0", res.getSystemId());
 		}
 		// 从角色树上截取子树
 		root = this.getChildrenByResId(root, resId);
 
 		//对结果封装
 		ret.setResName("root");// 附加信息，不影响树的显示
 		ret.setResId("0");
 		ret.setLeaf(false);
 		List<Resource> children = new ArrayList<Resource>();
 		children.add(root);
 		ret.setChildren(children);
 		return ret;
 	}
 
 	@Override
 	public List<String> findAllAuthForIdBySysIdAndRoleId(String systemId, String roleId) {
 		List<String> ret = null;
 		String sql = "select distinct auth_for_id from g2_t_authority where system_id='" + systemId + "' and auth_for_id like '%." + roleId + "'";
 		ret = (List<String>) super.baseDAO.queryListBySql(sql, null);
 		return ret;
 	}
 
 	@Override
 	public List<Resource> findAllAuthResOfParentByRoleCode(String parentCode, String roleCode) {
 		Role role = roleBusi.findRoleByRoleCode(roleCode);
 		Resource resource = resourceBusi.getResourceByCode(parentCode);
 		return findChildResourceListForRole(role.getRoleId(), resource.getResId(), resource.getSystemId());
 	}
 
 	@Override
 	public List<AuthorityOperationVO> findOperationsForUser(String groupId, String roleId, String userId, String resId) {
 		String[][] params = { { AuthorityOperationVO.class.getName() }, { QuerySupport.PARAM_DISTINCT, "true" },
 				{ "_authForId", groupId + "." + roleId + "." + userId }, { "_resId", resId }, { "_useStatus", "1" },
 				{ "_operationId_notnull", "true" } };
 		List<AuthorityOperationVO> operations = (List<AuthorityOperationVO>) baseDAO.queryList(params);
 		if (null == operations || 0 == operations.size()) {
 			//判断是否自动继承组角色的权限（查看登录用户否定制过，定制过则无需继承，因为是他定制的没有操作权限）
 			Resource res = (Resource) super.get(Resource.class, resId);
 			List<Authority> auth = this.findAuthoritiesByAuthForId(groupId + "." + roleId + "." + userId, res.getSystemId());
 			if (auth == null || auth.size() == 0) {
 				// TODO 如果用户定制之后为全部取消的状态，则无法判断是否定制过。此处按没有定制处理
 				// 没有定制过，说明还是初始化的状态，继承组角色
 				operations = this.findOperationsForRoleOfGroup(groupId, roleId, resId);
 			}
 		}
 		return operations;
 	}
 
 	@Override
 	public List<AuthorityResourceVO> findResourceOfSystemByAuthForId(String authForId, String systemId) {
 		if (StringUtils.isBlank(authForId) || StringUtils.isBlank(systemId)) {
 			throw new NullPointerException("authForId or systemId is not null!");
 		} else {
 			String[] ids = authForId.split("\\.");
 			int len = ids.length;
 			switch(len){
 				case 1 : return this.findResourceForRole(authForId, systemId);//角色权限
 				case 2 : return this.findResourceForGroupRole(authForId, systemId);//组角色权限
 				case 3 : return this.findResourceForGroupRoleUser(authForId, systemId);//登录用户权限
 				default : throw new DefaultGboatNestedException("authForId=【" + authForId + "】格式错误，应该为:groupId.roleId.userId。");
 			}
 		}
 	}
 	
 	
 	@Override
 	public boolean setDataLevelAuthority(String groupId, String roleId, String userId, String resId, String dataLevel) {
 		boolean ret = this.dataLevelAuthorityBusi.setDataLevelAuthority(groupId, roleId, userId, resId, dataLevel);
 		return ret;
 	};
 	
 
 	/**
 	 * 取得角色的所有权限
 	 * @author wangsr
 	 * @param roleId 角色id
 	 * @param systemId 系统id
 	 * @return 所有权限list
 	 */
 	private List<AuthorityResourceVO> findResourceForRole(String roleId, String systemId) {
 		List<AuthorityResourceVO> ret = this.getResourceForRoleOfSystem(roleId, systemId);
 		return ret;
 	};
 
 	/**
 	 * 取得组角色权限
 	 * @author wangsr
 	 * @param groupRoleId 组角色id
 	 * @param systemId 系统id
 	 * @return 权限list
 	 */
 	private List<AuthorityResourceVO> findResourceForGroupRole(String groupRoleId, String systemId) {
 		//对于组角色指定的权限authForId为“groupId.roleId”
 		List<AuthorityResourceVO> result = null;
 		// 读取组角色权限
 		result = this.getResourceForRoleOfSystem(groupRoleId, systemId);
 
 		/*
 		 *如果是用户组的角色权限，即groupId.roleId：如果还还没有定制过权限,则result为空（组角色的定制的标志，groupId.roleId是否存在）
 		 *但是，显示的时候，他应该拥有角色的所有权限，所以，查出角色的权限用于权限树的回填。
 		 *需要注意的是，此时数据库中并没有存储用户组角色的权限。
 		 *只有定制后，才会将角色的权限拷贝到用户组的角色中（第一次定制的时候，即第一次调用deleteAuthority方法的时候）
 		 */
 		if (result == null || result.size() == 0) {//没有定制过，或定制为空
 			// 查询出角色的权限
 			String[] splited = groupRoleId.split("\\.");
 			String roleId = splited[1];
 			result = this.getResourceForRoleOfSystem(roleId, systemId);
 			if (result != null && result.size() > 0) {
 				// 如果权限是继承的，则标识一下，以便使用
 				for (AuthorityResourceVO auRe : result) {
 					auRe.setInheritFlag("true");
 					auRe.setInheritFrom("role");
 				}
 			}
 		}
 		return result;
 	};
 
 	/**
 	 * 取得登录用户权限
 	 * @author wangsr
 	 * @param groupRoleUserId 组角色用户id
 	 * @param systemId 系统id
 	 * @return 权限list
 	 */
 	private List<AuthorityResourceVO> findResourceForGroupRoleUser(String groupRoleUserId, String systemId) {
 		//对于组角色用户指定的权限authForId为“groupId.roleId.userId”
 		List<AuthorityResourceVO> result = null;
 		// 登录用户的权限
 		result = this.getResourceForRoleOfSystem(groupRoleUserId, systemId);
 		if (null == result || result.size() == 0) {//没有定制过，从组角色继承
 			String[] ids = groupRoleUserId.split("\\.");
 			String groupRoleId = ids[0] + "." + ids[1];
 			result = this.findResourceForGroupRole(groupRoleId, systemId);
 			if (result != null && result.size() > 0) {
 				// 如果权限是继承的，则标识一下，以便使用
 				for (AuthorityResourceVO auRe : result) {
 					String inheritFlag = auRe.getInheritFlag();
 					if (!"true".equals(inheritFlag)) {
 						auRe.setInheritFlag("true");
 						auRe.setInheritFrom("group");
 					}
 				}
 			}
 		}
 		return result;
 	}
 	
 	/**
 	 * @author wangsr
 	 * @param root
 	 * @param resId
 	 * @return
 	 */
 	private AuthorityResourceVO getChildrenByResId(AuthorityResourceVO root, String resId) {
 		AuthorityResourceVO ret = null;
 		if (resId.equals(root.getResId())) {
 			ret = root;//递归结束的条件
 		} else {
 			List<Resource> list = root.getChildren();
 			if (list != null && list.size() > 0) {
 				for (Resource r : list) {
 					ret = this.getChildrenByResId((AuthorityResourceVO) r, resId);
 					if (null != ret && resId.equals(ret.getResId())) {
 						break;
 					}
 				}
 			}
 		}
 		return ret;
 	}
 
 	/**
 	 * 取得用户组角色权限树的一部分，如果resId==0是，取得全部的用户组角色权限树模块
 	 * @author wangsr
 	 * @param authForId 角色Id
 	 * @param resId 模块Id
 	 * @return 用户组的模块树
 	 */
 	private AuthorityResourceVO findResourceTreeForRoleOfGroup(String authForId, String resId, String systemId) {
 		AuthorityResourceVO root = null;
 		// 用户组角色的权限(authForId = groupId.roleId)，如果没有查到，则继承角色的权限
 		root = this.findResourceTreeForRole(authForId, resId, systemId);
 		// 用户没有定制权限，则继承角色的权限
 		if (null != root && 0 == root.getChildren().size() && authForId.indexOf(".") != -1) {
 			// 查询出角色的权限
 			String[] splited = authForId.split("\\.");
 			String roleId = splited[1];
 			root = this.findResourceTreeForRole(roleId, resId, systemId);
 		}
 		return root;
 	}
 
 	/**
 	 * 取得角色模块树的一部分（即：原角色模块树的一个节点），如果resId==0时，取得全部的角色权限树模块树
 	 * resId == 0的角色树<br>
 	 * |--a<br>
 	 * |--b<br>
 	 *   &nbsp;&nbsp;|--b1<br>
 	 *   &nbsp;&nbsp;|--b2<br>
 	 * |--c<br>
 	 * resId == b，则角色树的子树,形如：<br>
 	 * |--b<br>
 	 *   &nbsp;&nbsp;|--b1<br>
 	 *   &nbsp;&nbsp;|--b2<br>
 	 * @author wangsr
 	 * @param authForId 角色Id
 	 * @param resId 模块Id
 	 * @return 角色模块树
 	 */
 	private AuthorityResourceVO findResourceTreeForRole(String authForId, String resId, String systemId) {
 		AuthorityResourceVO root = new AuthorityResourceVO();
 		root.setResName("root");// 附加信息，不影响树的显示
 		root.setResId("0");
 		root.setLeaf(false);
 
 		List<Resource> list = findChildResourceListForRole(authForId, resId, systemId);
 
 		// 如果是角色权限树的子树，则应该包含当前模块；resName以##开头的模块除外.
 		if (!"0".equals(resId)) {
 			Resource curr = (Resource) this.resourceBusi.get(Resource.class, resId);
 			String resName = curr.getResName() + "";
 			//resName以##开头的模块除外.
 			if (!resName.startsWith("##")) {
 				if (curr != null) {
 					//当前模块的子树
 					List<Resource> sub = new ArrayList<Resource>();
 					// 将当前节点的子节点插入
 					curr.setChildren(list);
 					curr.setLeaf(this.isLeaf(curr));
 
 					// 将当前节点作为唯一的一个节点插入，因为子树前台要显示当前子节点
 					sub.add(curr);
 					root.setChildren(sub);
 				}
 			}
 		} else {
 			root.setChildren(list);
 		}
 		return root;
 	}
 	
 	
 	/**
 	 * 判断模块是否叶子节点
 	 * @author wangsr
 	 * @param res 模块
 	 * @return 是否是叶子节点
 	 */
 	private boolean isLeaf(Resource res) {
 		return null == res.getChildren() || res.getChildren().size() == 0;
 	}
 
 	/**
 	 * 递归查询模块的子节点
 	 * @author wangsr
 	 * @param res 模块
 	 * @param roleId 角色Id
 	 * @return 子节点
 	 */
 	private List<Resource> getChildrenRecursively(Resource res, String roleId) {
 		List<AuthorityResourceVO> children = this.getResourceForRole(roleId, res.getResId());
 		List<Resource> list = new ArrayList<Resource>();
 		for (AuthorityResourceVO child : children) {
 			child.setChildren(this.getChildrenRecursively(child, roleId));
 			child.setLeaf(this.isLeaf(child));
 
 			// 将AuthorityResource转化成Resource，用于展示，因为前者是后者的子类
 			// Resource tmp = child;
 			list.add(child);
 		}
 		return list;
 	}
 
 	/**
 	 * 取得角色某个模块的子模块
 	 * @author wangsr
 	 * @param roleId 角色id
 	 * @param parentResId 父模块id
 	 * @return 权限
 	 */
 	private List<AuthorityResourceVO> getResourceForRole(String roleId, String parentResId) {
 		//过滤resName的节点
 		String[][] params = { { AuthorityResourceVO.class.getName() }, { QuerySupport.PARAM_DISTINCT, "true" }, { "_authForId", roleId },
 				{ "_parentId", parentResId }, { "_useStatus", "1" }, { "_block", "RES_NAME not like '##%'" },
 				{ QuerySupport.PARAM_ORDERBY, "dispOrder" } };
 		return (List<AuthorityResourceVO>) baseDAO.queryList(params);
 	}
 
 	/**
 	 * 取得当前resID的所有直接子节点
 	 * @param authForId 角色Id
 	 * @param resId 模块Id
 	 * @param systemId 系统Id
 	 * @return
 	 */
 	private List<Resource> findChildResourceListForRole(String authForId, String resId, String systemId) {
 		// 取得当前resID的所有直接子节点
 		List<AuthorityResourceVO> tops = this.getAuthsByLevel(authForId, resId, systemId);
 
 		// 如果是子模块，当tops为空时，表示他还没有定制过权限，则需要继承角色的权限
 		if ((!"0".equals(resId)) && (tops == null || tops.size() == 0) && (authForId.indexOf(".") != -1)) {
 			// 查询出角色的权限
 			String[] splited = authForId.split("\\.");
 			authForId = splited[1];
 			tops = this.getAuthsByLevel(authForId, resId, systemId);
 		}
 
 		// 将List<AuthorityResourceVO> 转化为 List<Resource>
 		List<Resource> list = new ArrayList<Resource>();
 		for (AuthorityResourceVO authRes : tops) {
 			authRes.setChildren(this.getChildrenRecursively(authRes, authForId));
 			authRes.setLeaf(this.isLeaf(authRes));
 			list.add(authRes);
 		}
 		return list;
 	}
 	
 	/**
 	 * 根据authForId和systemId取得模块权限
 	 * @author wangsr
 	 * @param authForId authForId
 	 * @param systemId systemId
 	 * @return 权限
 	 */
 	private List<AuthorityResourceVO> getResourceForRoleOfSystem(String authForId, String systemId) {
 		List<AuthorityResourceVO> result = null;
 		String[][] params = { { AuthorityResourceVO.class.getName() }, { QuerySupport.PARAM_DISTINCT, "true" }, { "_authForId", authForId },
 				{ "_useStatus", "1" }, { QuerySupport.PARAM_ORDERBY, "dispOrder" }, { "_systemId", systemId } };
 		result = (List<AuthorityResourceVO>) super.baseDAO.queryList(params);
 		return result;
 	}
 	
 	
   /***********************************模块权限管理私有方法 start *********************************** */
 	
 	/**
 	 * 设置当前模块权限
 	 * @param authForId 角色Id
 	 * @param res 模块
 	 * @return 添加成功与否
 	 */
 	private boolean addResourceAuthority(String authForId, Resource res) {
 		// 查看当前模块是否被授权（组角色或登录用户的情况）
 		if (!this.isAuthorityExist(authForId, res.getResId())) {
 			// 获得当前模块的操作
 			List<Operation> operations = null;
 			operations = this.operaBusi.getOperationsByResourceId(res.getResId());
 			// 模块存在操作，添加每个操作的权限
 			for (Operation operation : operations) {
 				this.saveAuthority(authForId, res.getResId(), res.getSystemId(), operation.getOperationId(), "1");
 			}
 			//添加模块进入权限
 			this.saveAuthority(authForId, res.getResId(), res.getSystemId(), "", "1");
 
 			//添加角色或用户组权限时，恢复组内角色和用户继承的已经失效的权限（在删除权限的时候，使其失效的useStatus:0）
 			this.cascadeAuth(true, authForId, res.getResId(), null);
 		}
 		return true;
 	}
 	
 	
 	/**
 	 * 在第一次设置权限的时候(del)，级联授权
 	 * @author wangsr
 	 * @param authForId authForId
 	 * @param resId 模块id
 	 * @param systemId 系统id
 	 * @return 成功与否
 	 */
 	private boolean cascadeSetAuthAtFirstDel(String authForId, String resId, String systemId) {
 		
 		String[] ids = authForId.split("\\.");
 		String gId = ids[0];
 		String rId = "";
 		String uId = "";
 		int len = ids.length;
 		switch(len){
 			case 1 : return true; 
 			case 2 : rId = ids[1];uId = "";break;//groupId.roleId形式，需恢复用户定制的权限【以groupId.roleId开头】
 			case 3 : rId = ids[1];uId = ids[2];break;//roleId形式，需恢复组角色和用户定制的权限【以roleId结尾或roleId在中间的“XX.roleId.XX”】
 			default : throw new DefaultGboatNestedException("authForId=【" + authForId + "】格式错误，应该为:groupId.roleId.userId。");
 		}
 		
 		// 注意：此时不用考虑useStatus，auths是查看该用户组是否否定制过角色权限
 		List<Authority> auths = this.findAuthoritiesByAuthForId(authForId, systemId);
 		// 用户组或用户还没有定制角色
 		if (auths == null || auths.size() == 0) {
 			this.copyAuthorityFormRoleTo(rId, gId,uId, systemId);
 		} 
 		
 		return true;
 	}
 	
 	
 	/**
 	 * 拷贝权限到组角色或者用户(userId不为空则拷贝到用户)
 	 * @param roleId-- 角色Id
 	 * @param groupId-- 用户组Id
 	 * @param userId-- 用户Id
 	 * @param systemId-- 系统Id
 	 * @return
 	 */
 	private boolean copyAuthorityFormRoleTo(String roleId, String groupId, String userId, String systemId){
 		String authForId = "";
 		List<Authority> auths = null; 
 		if(StringUtils.isNotEmpty(userId)){//将组角色或角色的权限默认复制给登录用户（先看组角色有没有，没有再看角色）
 			authForId = groupId + "." + roleId;
 			auths = this.findAuthoritiesByAuthForId(authForId, systemId);//组角色的权限
 			if (null == auths || auths.size() == 0) {//组角色尚未定制，查看角色的权限
 				authForId = roleId;
 				auths = this.findAuthoritiesByAuthForId(authForId, systemId);
 			}
 			if (null == auths || auths.size() == 0) {
 				return true;
 			}
 			authForId = groupId + "." + roleId + "." + userId;
 			
 		}else{//将角色的权限默认复制给用户组的指定角色
 			auths = this.findAuthoritiesByAuthForId(roleId, systemId);
 			if (null == auths || auths.size() == 0) {
 				return true;
 			}
 			authForId = groupId + "." + roleId;
 		}
 		for (Authority authority : auths) {
 			this.saveAuthority(authForId, authority.getResId(), systemId, authority.getOperaId(), "1");// operaId可能为空
 		}
 		
 		return true;
 	}
 
 	/**
 	 * @param authForId 角色Id
 	 * @param res 模块
 	 * @return 添加成功与否
 	 */
 	private boolean addResourceAuthorityForParent(String authForId, Resource res) {
 		//循环处理父模块
 		Resource parent = (Resource) this.resourceBusi.get(Resource.class, res.getParentId());
 		while(parent != null){
 			if (!this.isAuthorityExist(authForId, parent.getResId())) {//如果父模块不存在
 				this.saveAuthority(authForId, parent.getResId(), res.getSystemId(), "", "1");//添加模块进入权限
 			}
 			parent = (Resource) this.resourceBusi.get(Resource.class, parent.getParentId());
 		}
 		return true;
 	}
 
 	/**
 	 * @param authForId 角色Id
 	 * @param res 模块
 	 * @return 添加成功与否
 	 */
 	private boolean addResourceAuthorityForChild(String authForId, Resource res) {
 		List<Resource> children = this.resourceBusi.getChildrenByParentId(res.getResId());
 		for (Resource child : children) {
 			addResourceAuthority(authForId, child);
 			addResourceAuthorityForChild(authForId, child);
 		}
 		return true;
 	}
 	
 	/**
 	 * 删除所有的还在节点权限
 	 * @param authForId
 	 * @param resId
 	 * @return
 	 */
 	private boolean deleteResourceAuthorityOfChild(String authForId, String resId) {
 		List<Resource> children = this.resourceBusi.getChildrenByParentId(resId);
 		for (Resource child : children) {
 			this.deleteResourceAuthority(authForId, child.getResId());// 删除子节点
 			// 递归调用自己，删除自己的子节点
 			deleteResourceAuthorityOfChild(authForId, child.getResId());
 		}
 		return true;
 	}
 
 	/**
 	 * 删除模块的权限 同时删除该模块所有子模块的权限
 	 * @param authForId 角色Id
 	 * @param resId 模块Id
 	 * @return 删除成功与否
 	 */
 	private boolean deleteResourceAuthority(String authForId, String resId) {
 		String hql = "delete from Authority where resId=:resId and authForId=:authForId";
 		Map<String, Object> params = new HashMap<String, Object>();
 		params.put("resId", resId);
 		params.put("authForId", authForId);
 		super.baseDAO.deleteByQuery(hql, params);
 		//如果删除的是角色的权限，则将用户组中定制的该角色相应的权限设置为无效
 		this.cascadeAuth(false, authForId, resId, null);
 		return true;
 	}
 	
 	/*****************************模块权限管理私有方法 end ***************************** */
 	
 	
 	/*****************************公用权限管理私有方法 start ***************************** */
 	
 	/**
 	 * 级联设置权限
 	 * @author wangsr
 	 * @param authForId authForId
 	 * @param authStatus true 设置权限为可用，false设置权限为不可用
 	 * @param operId 为空时级联恢复模块的权限， 不为空时级联恢复某个操作
 	 * @param resId res
 	 * @return 成功与否
 	 */
 	private boolean cascadeAuth(boolean authStatus, String authForId, String resId,String operaId) {
 		String[] ids = authForId.split("\\.");
 		int len = ids.length;
 		String authForIdLike = "";
 		switch(len){
 			case 3 : return true; 
 			case 2 : authForIdLike = authForId + ".%";break;//groupId.roleId形式，需恢复用户定制的权限【以groupId.roleId开头】
 			case 1 : authForIdLike = "%." + authForId + "%";break;//roleId形式，需恢复组角色和用户定制的权限【以roleId结尾或roleId在中间的“XX.roleId.XX”】
 			default : throw new DefaultGboatNestedException("authForId=【" + authForId + "】格式错误，应该为:groupId.roleId.userId。");
 		}
 		this.setAuthorityStatus(authStatus, authForIdLike, resId, operaId);
 		return true;
 	}
 	
 	
 	/**
 	 * 设置权限记录的状态
 	 * @param useStatus false无效，true有效
 	 * @param authForIdLike authForId的匹配形式
 	 * @param resId  模块Id
 	 * @return 查询集合
 	 */
 	private void setAuthorityStatus(boolean authStatus,String authForIdLike,String resId,String operaId){
 		String useStatusFrom = "1";
 		String useStatusTo = "0";
 		if(authStatus){
 			useStatusFrom = "0";
 			useStatusTo = "1";
 		} 
 		
 		String hql = "update Authority set useStatus=:useStatusTo where authForId like:authForIdLike and resId=:resId and useStatus=:useStatusFrom";
 		Map<String, Object> params = new HashMap<String, Object>();
 		params.put("authForIdLike", authForIdLike);
 		params.put("resId", resId);
 		params.put("useStatusFrom", useStatusFrom);
 		params.put("useStatusTo", useStatusTo);
 		
 		if(StringUtils.isNotEmpty(operaId)){//如果operaId不为空则设置操作权限
 			hql += " and operaId=:operaId"; 
 			params.put("operaId", operaId);
 		}
 		this.baseDAO.updateByQuery(hql, params);
 	}
 	
 	/**
 	 * 判断角色是否被授予这个模块的权限
 	 * @param authForId 角色Id
 	 * @param resId 模块Id
 	 * @return 是否授权
 	 */
 	private boolean isAuthorityExist(String authForId, String resId) {
 		String hql = "select count(*) from Authority where authForId=:authForId and resId=:resId";
 		Map<String, Object> params = new HashMap<String, Object>();
 		params.put("authForId", authForId);
 		params.put("resId", resId);
 		params.put("useStatus", "1");
 		List<?> result = super.baseDAO.queryListByHql(hql, params);
 		Long sum = (Long) result.get(0);
 		return sum.longValue() > 0;
 	}
 	
 	/**
 	 * 保存权限记录
 	 * @param authForId 
 	 * @param resId
 	 * @param systemId
 	 * @param operaId
 	 * @param useStatus
 	 * @return true 插入了记录  false未插入记录
 	 */
 	private boolean saveAuthority(String authForId,String resId,String systemId,String operaId,String useStatus){
 		if(StringUtils.isNotEmpty(authForId) && StringUtils.isNotEmpty(resId) &&
 				StringUtils.isNotEmpty(systemId)  && StringUtils.isNotEmpty(useStatus) ){
 			Authority auth = new Authority();
 			auth.setOperaId(operaId);
 			auth.setAuthForId(authForId);
 			auth.setResId(resId);
 			auth.setUseStatus(useStatus);
 			auth.setSystemId(systemId);
 			this.save(auth);
 			return true;
 		}
 		return false;
 	}
 	
 	private boolean deleteOpertionAuthorityBy(String authForId,String resId,String operaId){
 		String hql = "delete from Authority where operaId=:operaId and authForId=:authForId and resId=:resId";
 		Map<String, Object> params = new HashMap<String, Object>();
 		params.put("authForId", authForId);
 		params.put("resId", resId);
 		params.put("operaId", operaId);
 		baseDAO.deleteByQuery(hql, params);
 		return true;
 	}
 	
 	/*****************************公用权限管理私有方法 end ***************************** */
 }