RoleAction

/**
 * Copyright By Grandsoft Company Limited.
 * @author wangsr
 * @since jdk1.6
 * @date 2012-3-1 下午03:36:54
 */
package gboat2.web.action;

import gboat2.base.bridge.GboatAppContext;
import gboat2.base.bridge.model.UserSession;
import gboat2.base.core.annotation.Domain;
import gboat2.base.core.annotation.Module;
import gboat2.base.core.annotation.Operations;
import gboat2.base.core.logging.IBusinessLogService;
import gboat2.base.core.logging.Level;
import gboat2.base.core.web.BaseActionSupport;
import gboat2.base.core.web.JsonResult;
import gboat2.web.business.IAuthorityBusiness;
import gboat2.web.business.ICacheAssistBusiness;
import gboat2.web.business.IDataLevelAuthorityBusiness;
import gboat2.web.business.IGroupBusiness;
import gboat2.web.business.IGroupRoleBusiness;
import gboat2.web.business.IResourceBusiness;
import gboat2.web.business.IRoleBusiness;
import gboat2.web.business.ISystemConfigBusiness;
import gboat2.web.business.IUserBusiness;
import gboat2.web.model.AuthorityOperationVO;
import gboat2.web.model.AuthorityResourceVO;
import gboat2.web.model.Group;
import gboat2.web.model.Operation;
import gboat2.web.model.Resource;
import gboat2.web.model.Role;
import gboat2.web.model.SystemConfig;
import gboat2.web.model.UserRoleGroupOrganVO;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang3.StringUtils;
import org.apache.struts2.convention.annotation.ResultPath;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * 角色管理
 * @author wangsr
 * @since jdk1.6
 * @date 2012-3-13
 *
 */
@ResultPath("/content/role")
@Domain(value = Role.class)
@Module(name = "角色管理", desc = "管理各角色")
@Operations(value = {
        @gboat2.base.core.annotation.Operation(name = "新增角色", code = "add"),
        @gboat2.base.core.annotation.Operation(name = "编辑", code = "edit"),
        @gboat2.base.core.annotation.Operation(name = "删除", code = "ajaxDelete")
})
public class RoleAction extends BaseActionSupport {

	private static final long serialVersionUID = 472119966630760254L;

	private String roleCode;

	private String roleId;

	private String resId;

	private String systemId;

	@Autowired
	private IRoleBusiness roleBusiness;

	@Autowired
	private IGroupBusiness groupBusi;

	@Autowired
	private IResourceBusiness resBusiness;

	@Autowired
	private IAuthorityBusiness authorityBusi;

	@Autowired
	private IGroupRoleBusiness groupRoleBusi;

	@Autowired
	private IDataLevelAuthorityBusiness dataLevelAuthorityBusi;

	@Autowired
	private IBusinessLogService loggingService;

	@Autowired
	private ICacheAssistBusiness cacheAssistBusi;

	@Autowired
	private ISystemConfigBusiness systemCfgBusi;

	/**
	 * 用户服务
	 */
	@Autowired
	private IUserBusiness userService;

	/**
	 * 取得用户的角色，为用户切换角色所用
	 */
	public void rolesOfUser() {
		UserSession session = GboatAppContext.getUserSession();
		if (null == session) {
		    GboatAppContext.output(JsonResult.createFailure("对不起，用户未登录或者登录超时！"));
			return;
		}
		List<UserRoleGroupOrganVO> userStatus = userService.getMapperVOByUserId(session.getUserId());
		GboatAppContext.output(userStatus);
	}

	//取得系统中，权限定制过的用户组（非继承）
	public void findAllGroupOfCustom() {
		List<String> list = this.authorityBusi.findAllAuthForIdBySysIdAndRoleId(systemId, roleId);
		List<Group> groups = new ArrayList<Group>();
		if (list != null && list.size() > 0) {
			for (String authForId : list) {
				String groupId = authForId.substring(0, authForId.indexOf("."));
				Group tmp = (Group) this.groupBusi.get(Group.class, groupId);
				groups.add(tmp);
			}
		}
		GboatAppContext.output(groups);
	}

	public void groupAuthority() {

	}

	public void initEdit() {
		Role role = (Role) getModel();
		if (StringUtils.isEmpty(role.getRoleId())) {
			loggingService.log(Level.INFO, "新增", "新增角色:" + role.getRoleName());
		} else {
			loggingService.log(Level.INFO, "编辑", "编辑角色:" + role.getRoleName());
		}
	}

	public void postDelete() {
		Role role = (Role) getModel();
		String roleId = role.getRoleId();
		// TODO 提到roleBusiness中
		// 删除授权给该角色的模块权限
		this.authorityBusi.deleteAuthorityByRoleId(roleId);
		// 删除分配给用户组的角色（mapper）
		this.groupRoleBusi.deleteByRoleId(roleId);
		// 删除该角色在用户组中定制的权限
		this.dataLevelAuthorityBusi.deleteDataLevelAuthorityByRoleId(roleId);

		// 所有系统的缓存
		List<SystemConfig> allSys = systemCfgBusi.getAllSysCfg();
		if (allSys != null && allSys.size() > 0) {
			for (SystemConfig cfg : allSys) {
				// 删除该角色的权限缓存
				this.cacheAssistBusi.removeCacheOfPriority(roleId, cfg.getSystemId());
				// 删除该角色的导航缓存
				this.cacheAssistBusi.removeCacheOfMenuTree(roleId, cfg.getSystemId());
			}
		}

		loggingService.log(Level.INFO, "删除", "删除角色:" + role.getRoleName());
	}

	/**
	 * 取得指定模块的操作（初始化多选按钮）
	 */
	public void findOperationsForResource() {
		List<Operation> allOperas = this.authorityBusi.findOperationsForResource(resId);
		List<Map<String, Object>> items = new ArrayList<Map<String,Object>>();
		//items : [{boxLabel : '显示文字',name : '提交后台的参数名称',inputValue : '提交值'}}
		for (Operation opera : allOperas) {
		    Map<String, Object> map = new HashMap<String, Object>();
			map.put("boxLabel", opera.getOperationName());
			map.put("name", "operations");
			map.put("inputValue", opera.getOperationId());
			map.put("operationId", opera.getOperationId());
			items.add(map);
		}
		GboatAppContext.output(items);
	}

	/**
	 * 取得当前角色的指定模块的操作(回填多选按钮)
	 */
	public void findOperationsForRole() {
		List<AuthorityOperationVO> allOperas = this.authorityBusi.findOperationsForRole(resId, roleId);
		// 角色拥有操作的ID
		List<String> arr = new ArrayList<String>();
		for (AuthorityOperationVO auop : allOperas) {
			arr.add(auop.getOperationId());
		}
		GboatAppContext.output(arr);
	}

	@gboat2.base.core.annotation.Operation(name = "权限管理", code = "findResourceTree", desc = "权限管理")
	public void authority() {

	}

	/**
	 * 得到所有的模块，初始化模块树（初始化角色树）
	 */
	public void findResourceTree() {
		Resource tree = this.resBusiness.getResourcesTree(systemId);
		GboatAppContext.output(tree.getChildren());
	}

	/**
	 * 取得当前角色的所有权限（回填角色树）
	 */
	public void findResourceForRole() {
		List<AuthorityResourceVO> allRes = this.authorityBusi.findResourceOfSystemByAuthForId(roleId, systemId);
		// 角色拥有模块的ID
		List<String> resIds = new ArrayList<String>();
		for (AuthorityResourceVO authRes : allRes) {
			resIds.add(authRes.getResId());
		}
		GboatAppContext.output(resIds);
	}

	/**
	 * 检查角色编码是否存在
	 */
	public void checkRoleCode() {
		Boolean exist = Boolean.TRUE;
		this.roleCode = ((Role) this.getModel()).getRoleCode();
		Role r = this.roleBusiness.findRoleByRoleCode(this.roleCode);
		if (r == null) {
			exist = Boolean.FALSE;
		}
		String reason = "该角色编码已经存在！！";
		if (!exist) {
			reason = "该角色编码可以使用！！";
		}
		Map<String, Object> result = new HashMap<String, Object>();
		result.put("valid", !exist);
		result.put("reason", reason);
		GboatAppContext.output(result);
	}

	public String getRoleCode() {
		return roleCode;
	}

	public void setRoleCode(String roleCode) {
		this.roleCode = roleCode;
	}

	public String getRoleId() {
		return roleId;
	}

	public void setRoleId(String roleId) {
		this.roleId = roleId;
	}

	public String getResId() {
		return resId;
	}

	public void setResId(String resId) {
		this.resId = resId;
	}

	public String getSystemId() {
		return systemId;
	}

	public void setSystemId(String systemId) {
		this.systemId = systemId;
	}
}