/**
    * Copyright By Grandsoft Company Limited.  
    * 2012-3-1 下午02:12:42
    */
   package gboat2.web.action;
   
   import gboat2.base.bridge.GboatAppContext;
   import gboat2.base.bridge.util.json.JsonUtil;
   import gboat2.base.core.annotation.Domain;
  import gboat2.base.core.annotation.ListDomain;
  import gboat2.base.core.annotation.Module;
  import gboat2.base.core.annotation.Operation;
  import gboat2.base.core.annotation.Operations;
  import gboat2.base.core.dao.Page;
  import gboat2.base.core.dao.QuerySupport;
  import gboat2.base.core.logging.IBusinessLogService;
  import gboat2.base.core.logging.Level;
  import gboat2.base.core.util.SpringContextUtil;
  import gboat2.base.core.web.BaseActionSupport;
  import gboat2.base.core.web.JsonResult;
  import gboat2.base.core.web.JsonResultSupport;
  import gboat2.web.Constants;
  import gboat2.web.business.IAuthorityBusiness;
  import gboat2.web.business.IDataLevelAuthorityBusiness;
  import gboat2.web.business.IDataLevelBusiness;
  import gboat2.web.business.IGroupBusiness;
  import gboat2.web.business.ISystemConfigBusiness;
  import gboat2.web.business.IUserBusiness;
  import gboat2.web.model.AuthorityOperationVO;
  import gboat2.web.model.AuthorityResourceVO;
  import gboat2.web.model.DataLevel;
  import gboat2.web.model.Group;
  import gboat2.web.model.Profile;
  import gboat2.web.model.Resource;
  import gboat2.web.model.SystemConfig;
  import gboat2.web.model.User;
  import gboat2.web.model.UserGroupOrganMapper;
  import gboat2.web.model.UserRoleGroupOrganVO;
  import gboat2.web.model.UserURGOMapperVO;
  import gboat2.web.service.IOrganizationService;
  import gboat2.web.util.CXFClient;
  
  import java.util.Date;
  import java.util.List;
  import java.util.Map;
  
  import net.sf.json.JSONArray;
  import net.sf.json.JSONObject;
  
  import org.apache.commons.lang3.StringUtils;
  import org.apache.struts2.convention.annotation.ResultPath;
  import org.springframework.beans.factory.annotation.Autowired;
  
  import com.fasterxml.jackson.databind.node.ObjectNode;
  
  /**
   * 用户管理
   * 
   * @author zhaop
   * @author wangsr 2013-03-22
   * @since jdk1.6
   * @date 2012-3-1
   * 
   */
  @ResultPath(value = "/content/user")
  @ListDomain(value = UserURGOMapperVO.class)
  @Domain(value = User.class)
  @Module(name = "用户管理", desc = "管理用户")
  @Operations(value = {
          @Operation(name = "新增用户", code = "add", desc = "新增用户"),
          @Operation(name = "编辑", code = "edit", desc = "编辑用户"),
  		@Operation(name = "删除", code = "delete", desc = "删除"),
  		@Operation(name = "修改密码", code = "updatepass", desc = "修改用户密码")
  })
  public class UserAction extends BaseActionSupport {
  
  	private static final long serialVersionUID = 1L;
  
  	private String loginId;
  
  	private String organId;
  
  	private String organName;
  
  	private String groupId;
  
  	private String roleId;
  
  	private String serviceAddr;
  
  	private String serviceType;
  
  	private String password;
  
  	private String userId;
  
  	private String groupRoleId;
  
  	private String systemId;
 
 	private String authForId;
 
 	private String resId;
 
 	private String dataLevelId;
 
 	/** 用户修改密码中的原密码字段 */
 	private String oldPassword;
 	
 	private List<Group> groups;
 
 	@Autowired
 	private IUserBusiness userService;
 
 	@Autowired
 	private IGroupBusiness groupService;
 
 	@Autowired
 	private IBusinessLogService loggerService;
 
 	@Autowired
 	private IDataLevelBusiness dataLevelBusi;
 
 	@Autowired
 	private ISystemConfigBusiness systemCfgBusi;
 
 	@Autowired
 	private IAuthorityBusiness authBusi;
 
 	@Autowired
 	private IDataLevelAuthorityBusiness dataLevelAuthorityBusi;
 
 	public void setDataLevel() {
 		boolean retFlag = this.authBusi.setDataLevelAuthority(groupId, roleId, userId, resId, dataLevelId);
 		GboatAppContext.output(new JsonResult(retFlag));
 	}
 
 	@Operation(name = "权限管理", code = "userAuthority", desc = "用户权限管理")
 	public void userAuthority() {
 	}
 
 	/**初始化用户权限编辑页的准备数据*/
 	public void initEditUserAuth() {
 		this.get_M(); // 查询到要编辑的对象
 		List<DataLevel> allDataLevel = this.dataLevelBusi.findAllDataLevel();
 		List<UserRoleGroupOrganVO> allRole = this.userService.getMapperVOByUserId(this.getSID());
 		List<SystemConfig> allSys = this.systemCfgBusi.getAllSysCfg();
 
 		JSONObject root = new JSONObject();
 
 		// 所有系统
 		JSONArray systems = new JSONArray();
 		for (SystemConfig cfg : allSys) {
 			JSONArray arr = new JSONArray();
 			arr.add(cfg.getSystemId());
 			arr.add(cfg.getSystemName());
 			systems.add(arr);
 		}
 
 		// 所有的数据级别
 		JSONArray levels = new JSONArray();
 		for (DataLevel level : allDataLevel) {
 			JSONArray arr = new JSONArray();
 			arr.add(level.getLevelId());
 			arr.add(level.getLevelName());
 			levels.add(arr);
 		}
 
 		// 该用户组的所有角色
 		JSONArray roles = new JSONArray();
 		for (UserRoleGroupOrganVO grv : allRole) {
 			JSONArray arr = new JSONArray();
 			arr.add(grv.getGroupId() + "." + grv.getRoleId());
 			arr.add(grv.getRoleName() + "(" + grv.getGroupName() + ")");
 			roles.add(arr);
 		}
 
 		root.accumulate("systems", systems);
 		root.accumulate("levels", levels);
 		root.accumulate("roles", roles);
 
 		JsonResultSupport.output(root);
 	}
 
 	// 取得组角色的权限树，用于用户权限的配置
 	public void findResourceTreeForRoleOfGroup() {
 		Resource root = this.userService.findResourceTreeForRoleOfGroup(groupRoleId, systemId);
 		GboatAppContext.output(root.getChildren());
 	}
 
 	public void backAuthorityToRole() {
 		if (StringUtils.isNotEmpty(authForId)) {
 			// 删除客户定制的权限
 			authBusi.deleteAuthorityOfCustom(authForId, systemId);
 			// 删除客户定制的数据级别
 			if (authForId.split(".").length > 1) {
 				this.dataLevelAuthorityBusi.deleteDataLevelAuthority(authForId.split(".")[0], authForId.split(".")[1]);
 			}
 			GboatAppContext.output(JsonResult.SUCCESS);
 		}
 	}
 
 	// 取得具体用户的权限，回填权限树
 	public void findResourceForUser() {
 		//authForId：gid.rid.uid
 		List<AuthorityResourceVO> allRes = this.userService.findResourceForUser(authForId, systemId);
 		JSONObject root = new JSONObject();
 		// 角色拥有模块的ID
 		JSONArray resIds = new JSONArray();
 		String inheritFlag = "false";
 		for (AuthorityResourceVO authRes : allRes) {
 			resIds.add(authRes.getResId());
 			inheritFlag = authRes.getInheritFlag();
 		}
 		root.accumulate("inheritFlag", inheritFlag);
 		root.accumulate("resIds", resIds);
 		JsonResultSupport.output(root);
 
 	}
 
 	//取得登录用户的对该模块的数据界别权限
 	public void findDataLevelForUser() {
 		String[] rgId = this.groupRoleId.split("\\.");
 		String gId = rgId[0];
 		String rId = rgId[1];
 		String dataLevelOfResource = this.userService.findDataLevelForUser(gId, rId, resId, userId);
 		JSONObject obj = new JSONObject();
 		obj.accumulate("dataLevelOfResource", dataLevelOfResource);
 		JsonResultSupport.output(obj);
 	}
 
 	//取得组角色对模块的操作权限，用于用户的权限配置。
 	public void findOperationsForRoleOfGroup() {
 		String[] rgId = this.groupRoleId.split("\\.");
 		String gId = rgId[0];
 		String rId = rgId[1];
 		List<AuthorityOperationVO> allOperas = this.authBusi.findOperationsForRoleOfGroup(gId, rId, resId);
 		// 前台checkbox
 		JSONArray items = new JSONArray();
 		//items : [{boxLabel : '显示文字',name : '提交后台的参数名称',inputValue : '提交值'}}
 		for (AuthorityOperationVO opera : allOperas) {
 			JSONObject obj = new JSONObject();
 			obj.accumulate("boxLabel", opera.getOperationName());
 			obj.accumulate("name", "operations");
 			obj.accumulate("inputValue", opera.getOperationId());
 			obj.accumulate("operationId", opera.getOperationId());
 			items.add(obj);
 		}
 		JsonResultSupport.output(items);
 	}
 
 	//取得登录用户对模块的操作权限，用于回填
 	public void findOperationsForUser() {
 		String[] rgId = this.groupRoleId.split("\\.");
 		String gId = rgId[0];
 		String rId = rgId[1];
 		List<AuthorityOperationVO> ownOperas = this.authBusi.findOperationsForUser(gId, rId, userId, resId);
 		JSONArray arr = new JSONArray();
 		for (AuthorityOperationVO auOpe : ownOperas) {
 			arr.add(auOpe.getOperationId());
 		}
 		JsonResultSupport.output(arr);
 	}
 
 	@Override
 	protected void initList(Map<String, Object> params) {
 		params.put("_loginId_like", loginId);
 		params.put("_organName_like", organName);
 		params.put("_groupId", groupId);
 		params.put(QuerySupport.PARAM_DISTINCT, true);
 	}
 
 	@SuppressWarnings("unchecked")
 	@Override
 	protected void postList(Page pageinfo) {
 		List<UserURGOMapperVO> list = pageinfo.getResult();
 		for (UserURGOMapperVO mapper : list) {
 			List<UserRoleGroupOrganVO> mapperVO = userService.getMapperVOByUserId(mapper.getUserId());
 			String status = "";
 			for (UserRoleGroupOrganVO mvo : mapperVO) {
 				if (status == "") {
 					status = mvo.getOrganName() + "——" + mvo.getGroupName() + "——" + mvo.getRoleName();
 				} else {
 					status += " , " + mvo.getOrganName() + "——" + mvo.getGroupName() + "——" + mvo.getRoleName();
 				}
 			}
 			mapper.setDescription(status);
 		}
 		
 		groups = groupService.getAllGroup();
 	}
 
 	/**
 	 * 获取用户信息
 	 * @return
 	 * @author zhaop
 	 */
 	public void showUser() {
 		User user = (User) userService.get(User.class, getSID());
 		List<UserRoleGroupOrganVO> mapper = userService.getMapperVOByUserId(getSID());
 		JSONObject obj = JsonResultSupport.wrap(user, true).accumulate("status", mapper);
 		JsonResultSupport.output(obj);
 	}
 
 	/**
 	 * 保存user,同时保存用户，角色，用户组，组织机构关联表相关数据
 	 * 
 	 * @return
 	 * @author zhaop
 	 */
 	public void saveUser() {
 		User user = (User) getModel();
 		String userId = "";
 		if (user.getUserId() == null) {
 			user.setCommitTime(new Date());
 			userService.save(user);
 			//初始化用户信息
 			user = userService.getUserByLoginId(user.getLoginId());
 			Profile profile = new Profile();
 			profile.setUserId(user.getUserId());
 			profile.setTheme(Constants.DEFAULT_THEME);
 			profile.setWallPaper(Constants.DEFAULT_THEME);
 			profile.setStretch("0");
 
 			userService.save(profile);
 			loggerService.log(Level.INFO, "新增", "新增用户  ： " + user.getUserNameZh());
 			userId = userService.getUserByLoginId(user.getLoginId()).getUserId();
 		} else {
 			userId = user.getUserId();
 			User oldUser = (User) userService.get(User.class, userId);
 			user.setCommitTime(oldUser.getCommitTime());
 			user.setPassword(oldUser.getPassword());
 			user.setVisible(oldUser.getVisible());
 
 			userService.update(user);
 			loggerService.log(Level.INFO, "编辑", "编辑用户  ： " + user.getUserNameZh());
 			userService.deleteURGOMapperByUserId(userId);
 		}
 
 		String[] organIds = organId.split("-");
 		String[] organNames = organName.split("-");
 		String[] groupIds = groupId.split("-");
 		String[] roleIds = roleId.split("-");
 		for (int i = 0; i < organIds.length; i++) {
 			UserGroupOrganMapper mapper = new UserGroupOrganMapper();
 			mapper.setUserId(userId);
 			mapper.setGroupId(groupIds[i]);
 			mapper.setRoleId(roleIds[i]);
 			mapper.setOrganId(organIds[i]);
 			mapper.setOrganName(organNames[i]);
 			userService.save(mapper);
 		}
 		JsonResultSupport.output(JsonResultSupport.wrap(true));
 	}
 
 	/**
 	 * 删除user,同时删除用户，角色，用户组，组织机构关联表相关数据
 	 * 
 	 * @author zhaop
 	 */
 	public void deleteUserRoleGroupOrgan() {
 		User user = (User) userService.get(User.class, getSID());
 		userService.delete(user);
 		userService.deleteURGOMapperByUserId(getSID());
 		loggerService.log(Level.INFO, "删除", "删除用户 ： " + user.getUserNameZh());
 		GboatAppContext.output(JsonResult.SUCCESS);
 	}
 
 	/**
 	 * 根据id删除mapper
 	 * 
 	 * @author zhaop
 	 */
 	public void deleteMapperById() {
 		userService.delete(userService.get(UserGroupOrganMapper.class, getSID()));
 		GboatAppContext.output(JsonResult.SUCCESS);
 	}
 
 	/**
 	 * 判断用户名是否存在
 	 * 
 	 * @return
 	 * @author zhaop
 	 */
 	public void userExist() {
 		JSONObject jsonString = new JSONObject();
 		User userExist = null;
 		if (getSID() == null) {//新增
 			User user = (User) getModel();
 			userExist = userService.getUserByLoginId(user.getLoginId());
 			if (userExist == null) {//用户名可用
 				jsonString.accumulate("valid", true);
 			} else {//用户名不可用
 				jsonString.accumulate("valid", false);
 				jsonString.accumulate("reason", "用户名已经被占用");
 			}
 		} else {
 			userExist = userService.getUserByLoginId(loginId);
 			if (userExist == null) {//用户可用
 				jsonString.accumulate("valid", true);
 			} else {//用户名不可用
 				if (userExist.getUserId().equals(getSID())) {
 					jsonString.accumulate("valid", true);
 				} else {
 					jsonString.accumulate("valid", false);
 					jsonString.accumulate("reason", "用户名已经被占用");
 				}
 			}
 		}
 		GboatAppContext.output(jsonString);
 	}
 
 	/**
 	 * 根据id获取UserRoleGroupOrganMapper
 	 * 
 	 * @return
 	 * @author zhaop
 	 */
 	public void showMapperById() {
 	    GboatAppContext.output(JsonResult.createSuccess(userService.getMapperVOByUserId(getSID())));
 	}
 
 	/**
 	 * 根据groupId获取所有的GroupOrganVO
 	 * 
 	 * @return
 	 * @author zhaop
 	 */
 	public void showGroupOrganMapperById() {
 	    GboatAppContext.output(JsonResult.createSuccess(userService.getGroupOrganByGroupId(getSID())));
 	}
 
 	public String showAllGroup() {
 	    GboatAppContext.output(JsonResult.createSuccess(groupService.getAllGroup()));
 		return null;
 	}
 
 	/**
 	 * 跳转到修改密码的页面
      * @author hemw
 	 * @return
 	 */
 	public String password() {
 		return "password";
 	}
 
     /**
      * 动态验证密码是否和原来的密码相同
      * 接收SID,判断SID是否存在，存在则使用SID获取用户信息，不存在则通过session获取用户信息
      */
     public void passwordConfirm() {
         String userId = StringUtils.defaultIfBlank(getSID(), GboatAppContext.getUserSession().getUserId());
         User user = (User) userService.get(User.class, userId);
         User newUser = (User) getModel();
         ObjectNode result = JsonUtil.generateMapper().createObjectNode();
         if (StringUtils.equals(newUser.getPassword(), user.getPassword())) {  //新旧密码一致
             result.put("valid", false);
             result.put("reason", "新旧密码不可以相同");
         } else {
             result.put("valid", true);
         }
         GboatAppContext.output(result);
     }
 
 	/**
 	 * 修改密码
 	 * @return
 	 */
 	public String passwordModify() {
 		User user = (User) getModel();
 		String userId = StringUtils.defaultIfBlank(user.getUserId(), GboatAppContext.getUserSession().getUserId());
 		User oldUser = (User) userService.get(User.class, userId);
 		oldUser.setPassword(user.getPassword());
 		oldUser.setPasswordModify("N");
 		userService.update(oldUser);
 		GboatAppContext.output(JsonResult.SUCCESS);
 		return null;
 	}
 
 	/**
 	 * 用户修改密码功能
 	 * @author hemw
 	 */
 	public void passwordModifyByUser() {
 	    User model = (User) getModel();
 	    String userId = StringUtils.defaultIfBlank(model.getUserId(), GboatAppContext.getUserSession().getUserId());
 	    User user = (User) userService.get(User.class, userId);
    
 		// 验证原密码
 		if (!StringUtils.equals(oldPassword, user.getPassword())) {
 		    GboatAppContext.output(JsonResult.createFailure("原密码输入错误"));
 			return;
 		}
 		
 		// 检查新旧密码是否相同
 		if (StringUtils.equals(model.getPassword(), user.getPassword())) {
 		    GboatAppContext.output(JsonResult.createFailure("新旧密码不可以相同"));
 		    return;
         }
 		
 		user.setPassword(model.getPassword()); // 更新新密码
 		user.setPasswordModify("N"); // 设置为登录时不需要修改密码
 		userService.update(user);
 		GboatAppContext.output(JsonResult.SUCCESS);
 	}
 
 	public String showOrgansByAddr() {
 		IOrganizationService organService;
 		if (serviceType.equals("1")) {
 			Object bean = SpringContextUtil.getInstance().getBeanOfId(serviceAddr);
 			organService = (IOrganizationService) bean;
 		} else {
 			organService = CXFClient.getInstance().createOrganWebService(serviceAddr);
 		}
 		if (organService != null) {
 			Page organs = organService.searchOrgans(1, 20, organName);
 			JsonResultSupport.outputPage(organs);
 		} else {
 		    GboatAppContext.output(JsonResult.SUCCESS);
 		}
 		return null;
 	}
 
 	public String getLoginId() {
 		return loginId;
 	}
 
 	public void setLoginId(String loginId) {
 		this.loginId = loginId;
 	}
 
 	public String getOrganName() {
 		return organName;
 	}
 
 	public void setOrganName(String organName) {
 		this.organName = organName;
 	}
 
 	public String getOrganId() {
 		return organId;
 	}
 
 	public void setOrganId(String organId) {
 		this.organId = organId;
 	}
 
 	public String getRoleId() {
 		return roleId;
 	}
 
 	public void setRoleId(String roleId) {
 		this.roleId = roleId;
 	}
 
 	public String getGroupId() {
 		return groupId;
 	}
 
 	public void setGroupId(String groupId) {
 		this.groupId = groupId;
 	}
 
 	public String getServiceAddr() {
 		return serviceAddr;
 	}
 
 	public void setServiceAddr(String serviceAddr) {
 		this.serviceAddr = serviceAddr;
 	}
 
 	public String getPassword() {
 		return password;
 	}
 
 	public void setPassword(String password) {
 		this.password = password;
 	}
 
 	public String getServiceType() {
 		return serviceType;
 	}
 
 	public void setServiceType(String serviceType) {
 		this.serviceType = serviceType;
 	}
 
 	public String getOldPassword() {
 		return oldPassword;
 	}
 
 	public void setOldPassword(String oldPassword) {
 		this.oldPassword = oldPassword;
 	}
 
 	public String getUserId() {
 		return userId;
 	}
 
 	public void setUserId(String userId) {
 		this.userId = userId;
 	}
 
 	public String getGroupRoleId() {
 		return groupRoleId;
 	}
 
 	public void setGroupRoleId(String groupRoleId) {
 		this.groupRoleId = groupRoleId;
 	}
 
 	public String getSystemId() {
 		return systemId;
 	}
 
 	public String getAuthForId() {
 		return authForId;
 	}
 
 	public void setSystemId(String systemId) {
 		this.systemId = systemId;
 	}
 
 	public void setAuthForId(String authForId) {
 		this.authForId = authForId;
 	}
 
 	public String getResId() {
 		return resId;
 	}
 
 	public void setResId(String resId) {
 		this.resId = resId;
 	}
 
 	public String getDataLevelId() {
 		return dataLevelId;
 	}
 
 	public void setDataLevelId(String dataLevelId) {
 		this.dataLevelId = dataLevelId;
 	}
 
     public List<Group> getGroups() {
         return groups;
     }
 }