NC6 主辅数量换算的工具类

主辅数量换算的工具类

package nc.impl.pubitf.rbac;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import nc.bs.businessevent.bd.BDCommonEventUtil;
import nc.bs.dao.BaseDAO;
import nc.bs.framework.common.InvocationInfoProxy;
import nc.bs.framework.common.NCLocator;
import nc.bs.framework.core.util.ObjectCreator;
import nc.bs.ml.NCLangResOnserver;
import nc.bs.rbac.pubqry.RolePermBaseQuery;
import nc.bs.uap.rbac.profile.SubjectOrgRuleUtil;
import nc.itf.bd.pub.IBDMetaDataIDConstBasic;
import nc.itf.uap.rbac.IUserManage;
import nc.itf.uap.rbac.IUserManageQuery;
import nc.itf.uap.rbac.userpassword.IUserPasswordManage;
import nc.jdbc.framework.SQLParameter;
import nc.jdbc.framework.processor.BeanListProcessor;
import nc.jdbc.framework.processor.ColumnListProcessor;
import nc.jdbc.framework.processor.ResultSetProcessor;
import nc.login.vo.ILoginConstants;
import nc.pubitf.rbac.IUserPubConstants;
import nc.pubitf.rbac.IUserPubService;
import nc.pubitf.rbac.PubServiceSqlUtils;
import nc.vo.bd.pub.IPubEnumConst;
import nc.vo.jcom.lang.StringUtil;
import nc.vo.pub.BusinessException;
import nc.vo.pub.lang.UFDate;
import nc.vo.pub.lang.UFDateTime;
import nc.vo.sm.UserVO;
import nc.vo.sm.enumfactory.UserIdentityTypeEnumFactory;
import nc.vo.trade.sqlutil.IInSqlBatchCallBack;
import nc.vo.trade.sqlutil.InSqlBatchCaller;
import nc.vo.trade.summarize.Hashlize;
import nc.vo.trade.summarize.IHashKey;
import nc.vo.uap.rbac.ResponsibilityVO;
import nc.vo.uap.rbac.SubjectOrgVO;
import nc.vo.uap.rbac.UserPasswordLogVO;
import nc.vo.uap.rbac.rule.orgrule.IOrgRuleStrategy;
import nc.vo.uap.rbac.rule.orgrule.OrgRuleContext;
import nc.vo.uap.rbac.util.RbacPubUtil;
import nc.vo.uap.rbac.util.RbacSqlUtils;
import nc.vo.uap.rbac.util.RbacUserPwdUtil;
import nc.vo.util.BDPKLockUtil;
import nc.vo.util.SqlWrapper;
import nc.vo.util.innercode.NamedParamUtil;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.iterators.EntrySetMapIterator;
import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.StringUtils;

public class UserPubServiceImpl implements IUserPubService {

	@Override
	public String queryPsndocByUserid(String cuserid) throws BusinessException {
		IUserManageQuery qryService = (IUserManageQuery) nc.bs.framework.common.NCLocator
				.getInstance().lookup(IUserManageQuery.class.getName());

		return qryService.queryPsndocByUserid(cuserid);
	}

	@Override
	public void updateLockedTag(String cuserid, boolean isLocked)
			throws BusinessException {
		IUserManage manageService = (IUserManage) nc.bs.framework.common.NCLocator
				.getInstance().lookup(IUserManage.class.getName());

		manageService.updateLockedTag(cuserid, isLocked);
	}

	@Override
	public UserVO queryUserVOByPsnDocID(String pkPsndoc)
			throws BusinessException {
		IUserManageQuery qryService = (IUserManageQuery) nc.bs.framework.common.NCLocator
				.getInstance().lookup(IUserManageQuery.class.getName());

		return qryService.queryUserVOByPsnDocID(pkPsndoc);
	}

	@SuppressWarnings("unchecked")
	@Override
	public UserVO[] queryUserVOsByPsnDocID(String pk_psndoc, String pk_group)
			throws BusinessException {
		String condition = "base_doc_type = ? and pk_base_doc = ? ";
		SQLParameter p = new SQLParameter();
		p.addParam(UserIdentityTypeEnumFactory.TYPE_PERSON);
		p.addParam(pk_psndoc);

		if (StringUtils.isNotBlank(pk_group)) {
			condition += " and pk_group = ?";
			p.addParam(pk_group);
		}

		BaseDAO dao = new BaseDAO();
		Collection<UserVO> c = dao.retrieveByClause(UserVO.class, condition, p);

		return CollectionUtils.isEmpty(c) ? null : c.toArray(new UserVO[0]);
	}

	@SuppressWarnings("unchecked")
	@Override
	public HashMap<String, UserVO[]> batchQueryUserVOsByPsnDocID(
			String[] psndocPks, final String pk_group) throws BusinessException {
		if (ArrayUtils.isEmpty(psndocPks))
			return null;

		try {
			InSqlBatchCaller caller = new InSqlBatchCaller(psndocPks);
			List<UserVO> userResultList = (List<UserVO>) caller
					.execute(new IInSqlBatchCallBack() {
						List<UserVO> userResultList = new ArrayList<UserVO>();

						@Override
						public Object doWithInSql(String inSql)
								throws BusinessException, SQLException {
							String condition = " base_doc_type = ? ";
							SQLParameter p = new SQLParameter();
							p.addParam(UserIdentityTypeEnumFactory.TYPE_PERSON);

							if (StringUtils.isNotBlank(pk_group)) {
								condition += " and pk_group = ?";
								p.addParam(pk_group);
							}

							condition += " and pk_base_doc in " + inSql;

							BaseDAO dao = new BaseDAO();
							Collection<UserVO> tempResult = dao
									.retrieveByClause(UserVO.class, condition,
											p);

							if (CollectionUtils.isNotEmpty(tempResult))
								userResultList.addAll(tempResult);

							return userResultList;
						}

					});

			HashMap<String, UserVO[]> psndoc_users_map = new HashMap<String, UserVO[]>();

			if (CollectionUtils.isNotEmpty(userResultList)) {
				HashMap<String, List<UserVO>> psndoc_userList_map = Hashlize
						.hashlizeVOs(userResultList.toArray(new UserVO[0]),
								new IHashKey() {
									@Override
									public String getKey(Object o) {
										UserVO user = (UserVO) o;
										return user.getPk_base_doc();
									}

								});

				EntrySetMapIterator mapIterator = new EntrySetMapIterator(
						psndoc_userList_map);
				while (mapIterator.hasNext()) {
					String psndoc = (String) mapIterator.next();
					List<UserVO> userList = (List<UserVO>) mapIterator
							.getValue();

					psndoc_users_map.put(psndoc,
							userList.toArray(new UserVO[0]));
				}
			}

			return psndoc_users_map;

		} catch (Exception ex) {
			throw new BusinessException(ex.getMessage());
		}

	}

	@Override
	public UserPasswordLogVO[] queryUserPasswordLog(String cuserid)
			throws BusinessException {

		String condition = "cuserid = ?";
		SQLParameter p = new SQLParameter();
		p.addParam(cuserid);

		return queryUserPasswordLogByDefCond(condition, p);
	}

	@SuppressWarnings("unchecked")
	@Override
	public UserPasswordLogVO[] queryUserPasswordLogByDefCond(
			String defCondition, SQLParameter sp) throws BusinessException {
		BaseDAO dao = new BaseDAO();
		List<UserPasswordLogVO> list = (List<UserPasswordLogVO>) dao
				.retrieveByClause(UserPasswordLogVO.class, defCondition, sp);
		return list == null ? null : (UserPasswordLogVO[]) list
				.toArray(new UserPasswordLogVO[list.size()]);
	}

	@Override
	public int checkUserPwd(String usercode, String password)
			throws BusinessException {
		IUserManageQuery qryService = (IUserManageQuery) nc.bs.framework.common.NCLocator
				.getInstance().lookup(IUserManageQuery.class.getName());

		String dsName = InvocationInfoProxy.getInstance().getUserDataSource();
		UserVO user = qryService.findUserByCode(usercode, dsName);
		if (user == null)
			return ILoginConstants.USER_NAME_WRONG;

		if (!RbacUserPwdUtil.checkUserPassword(user, password))
			return ILoginConstants.USER_NAME_RIGHT_PWD_WRONG;

		return checkUser(user, new UFDate());

	}

	private int checkUser(UserVO user, UFDate today) {

		if (user.getAbledate() != null && today.before(user.getAbledate())) {
			return ILoginConstants.USER_BEFORE_EFFECT;
		}
		if (user.getDisabledate() != null && today.after(user.getDisabledate())) {
			return ILoginConstants.USER_AFTER_EXPIRED;
		}
		if (user.getEnablestate() != null
				&& user.getEnablestate() != IPubEnumConst.ENABLESTATE_ENABLE) {
			if (user.getEnablestate() == IPubEnumConst.ENABLESTATE_DISABLE) {
				return ILoginConstants.USER_DISABLE;
			} else {
				return ILoginConstants.USER_UNENABLE;
			}
		}
		return ILoginConstants.USER_IDENTITY_LEGAL;
	}

	@SuppressWarnings("unchecked")
	@Override
	public boolean checkUserUnique(String usercode) throws BusinessException {
		String usercode_q = StringUtils.upperCase(usercode);

		String condition = " user_code_q = ?";

		SQLParameter sp = new SQLParameter();
		sp.addParam(usercode_q);

		BaseDAO dao = new BaseDAO();
		Collection<UserVO> user = dao.retrieveByClause(UserVO.class, condition,
				sp);

		return CollectionUtils.isEmpty(user);
	}

	@Override
	public ResponsibilityVO[] getRespsRelatedWithUserAndPermOrgs(
			final String cuserid, String[] orgPKs) throws BusinessException {
		if (StringUtils.isEmpty(cuserid) || ArrayUtils.isEmpty(orgPKs))
			return null;
		orgPKs=getRolesHasPermOrgs(cuserid, orgPKs);
		HashSet<String> rolePKResult = fetchRolesHasOrgPerm(cuserid, orgPKs);

//		String pk_group = InvocationInfoProxy.getInstance().getGroupId();
//		Map> roleWithRuleOrgs=getRuleOrgs(cuserid, pk_group);
//		if(roleWithRuleOrgs!=null){
//			for(String role:roleWithRuleOrgs.keySet()){
//				for(String org:orgPKs){
//					if(roleWithRuleOrgs.get(role)!=null&&roleWithRuleOrgs.get(role).contains(org)){
//						rolePKResult.add(role);
//						break;
//					}
//				}
//			}
//		}
		if (CollectionUtils.isEmpty(rolePKResult))
			return null;

		List<ResponsibilityVO> respResultList = fetchResponsibilityRelateRoles(rolePKResult);

		return CollectionUtils.isEmpty(respResultList) ? null : respResultList
				.toArray(new ResponsibilityVO[0]);
	}
	@SuppressWarnings("unchecked")
	private String[]getRolesHasPermOrgs(String cuserid,String[]orgPKs) throws BusinessException{
		if(orgPKs==null||orgPKs.length==0){
			return orgPKs;
		}
		List<String> rolePKResult =new ArrayList<String>();
		rolePKResult.addAll(Arrays.asList(orgPKs));
		String pk_group = InvocationInfoProxy.getInstance().getGroupId();
		Map<String, Map<String, Set<String>>> roleWithRuleOrgs=getRuleOrgs(cuserid,pk_group);
		if(roleWithRuleOrgs!=null){
			for(String role:roleWithRuleOrgs.keySet()){
				for(String org:orgPKs){
					rolePKResult.add(org);
					Map<String, Set<String>>ruleOrgs=roleWithRuleOrgs.get(role);
					if(!ruleOrgs.isEmpty()){
						for(String ruleid:ruleOrgs.keySet()){
							if(ruleOrgs.get(ruleid).contains(org)){
								rolePKResult.add(ruleid);
								break;
							}
						}
					}
				}
			}
		}
		return rolePKResult.toArray(new String[0]);
	}
	
	//*******************************************START********************************************
	/**
	 * 规则计算出的组织
	 * @param cuserid
	 * @param pk_group
	 * @return
	 * @throws BusinessException
	 */
	@SuppressWarnings("unchecked")
	private Map<String, Map<String, Set<String>>>getRuleOrgs(String cuserid, String pk_group) throws BusinessException { 
		BaseDAO dao = new BaseDAO();
		String sql = RbacSqlUtils.QUERY_ALLORGRULES_USERPERM_SQL;

		SqlWrapper wrapper = new SqlWrapper(sql);
		wrapper.bind("cuserid", cuserid);
		wrapper.bind("nowtime", new UFDateTime());
		wrapper.bind("pk_group", pk_group);
		Map<String, Set<String>> result =new HashMap<String, Set<String>>();
		Map<String, SubjectOrgVO> Subjects =new HashMap<String, SubjectOrgVO>();
		List<SubjectOrgVO> retList  = (List<SubjectOrgVO>)dao.executeQuery(wrapper.getSql(), wrapper.getSqlParameter(), 
				new BeanListProcessor(SubjectOrgVO.class));

		processSubjectAndOrgRelation(result, retList, Subjects);
		
		Map<String, Map<String, Set<String>>> ret = new HashMap<String, Map<String, Set<String>>>();
		sql = "select pk_rule,ruleclass from sm_rule";
		Map<String, String> ruleTypeMap = (Map<String, String>) dao.executeQuery(sql, new ResultSetProcessor() {
			@Override
			public Object handleResultSet(ResultSet rs) throws SQLException {
				Map<String, String> rules = new HashMap<String, String>();
				while (rs.next()) {
				
					String pk = rs.getString("pk_rule");
					String ruleclass = rs.getString("ruleclass");
					if(!rules.containsKey(pk))
					{
						rules.put(pk, ruleclass);
					}
				} 
				return rules;
			}
		});

		if (ruleTypeMap == null) {
			return null;
		}
		
		IUserManageQuery umq = (IUserManageQuery) NCLocator.getInstance().lookup(IUserManageQuery.class.getName());
		UserVO userVO = umq.getUser(cuserid);
		if (userVO == null) {
			return null;
		}
		
		Map<String, List<String>> ruleOrgs = new HashMap<String, List<String>>();
		Map<String, String> ruleTS = new HashMap<String, String>();
		Set<String> subjects = result.keySet();
		for (String subject : subjects) {
			Set<String> orgids = result.get(subject);
			if (orgids == null ) {
				continue;
			}
			for (String id : orgids.toArray(new String[0])) {
				if (SubjectOrgRuleUtil.isRule(id)) {
					if (!ret.containsKey(subject)){
						ret.put(subject, new HashMap<String, Set<String>>());
					}
					Map<String, Set<String>> orgsBySubject = ret.get(subject);
					String subjectID = SubjectOrgRuleUtil.getRuleIdbySetKey(id);
					SubjectOrgVO ruleSubVO=Subjects.get(subjectID);
					String ruleId = ruleSubVO.getPk_org();
//					if (!ruleTS.containsKey(ruleId)) {
						String ruleClass = ruleTypeMap.get(ruleId);
						List<String> tempOrgs = this.queryAssignedRuleOrgs(ruleClass, userVO,  ruleId,ruleSubVO.getRulepar());
						ruleOrgs.put(ruleId, tempOrgs);
//					}

					String ts = ruleTS.get(ruleId);
					String key = ruleId;
					
					if (!orgsBySubject.containsKey(key)) {
						orgsBySubject.put(key, new HashSet<String>());
					}
					if(ruleOrgs.get(ruleId) != null) {
						orgsBySubject.get(key).addAll(ruleOrgs.get(ruleId));
					}
				}
			}
		}
		return ret;
	}
	
	private void processSubjectAndOrgRelation(
			Map<String, Set<String>> result, List<SubjectOrgVO> retList,
			Map<String, SubjectOrgVO> subjects) {
		for(SubjectOrgVO vo:retList){
			if (StringUtils.isNotEmpty(vo.getSubjectid())) {
				Set<String> orgPksSet = result.get(vo.getSubjectid());
				if (orgPksSet == null) {
					orgPksSet = new HashSet<String>();
				}
				if(!StringUtil.isEmptyWithTrim(vo.getPk_org())) {
					if (!StringUtils.equalsIgnoreCase(vo.getIsrule(), "Y") ? true : false) {
						orgPksSet.add(vo.getPk_org());
					}
					else {
						orgPksSet.add(SubjectOrgRuleUtil.getSetKey(vo.getPk_subject_org()));
						 subjects.put(vo.getPk_subject_org(), vo);
					}
				}
				
				result.put(vo.getSubjectid(), orgPksSet);
			}
		}
		
	}
	private List<String> queryAssignedRuleOrgs(String ruleClass, UserVO userVO, String ruleId, String rulepar) throws BusinessException {
		IOrgRuleStrategy strategy;
		try {
			strategy = (IOrgRuleStrategy) ObjectCreator.newInstance(ruleClass);
		}
		catch (Exception e) {
			return null;
		}
		OrgRuleContext orgRuleContext = new OrgRuleContext();
		orgRuleContext.setUservo(userVO);
		if(!StringUtil.isEmptyWithTrim(rulepar)){
			strategy.setPar(rulepar);
		}
		List<String> tempOrgs = strategy.getOrgs(orgRuleContext);
		return tempOrgs;
	}
	//**************************************END*************************************************
	@SuppressWarnings("unchecked")
	private HashSet<String> fetchRolesHasOrgPerm(final String cuserid,
			String[] orgPKs) throws BusinessException {
		try {
			InSqlBatchCaller roleCaller = new InSqlBatchCaller(orgPKs);
			HashSet<String> rolePKResult = (HashSet<String>) roleCaller
					.execute(new IInSqlBatchCallBack() {
						HashSet<String> rolePKResult = new HashSet<String>();

						@Override
						public Object doWithInSql(String inSql)
								throws BusinessException, SQLException {

							NamedParamUtil npu = new NamedParamUtil();
							npu.addNamedParam("orgPKs", inSql);

							String queryRoleSql = npu
									.format(PubServiceSqlUtils.USER_OWNED_ROLESWITHORGS);
							SqlWrapper sw = new SqlWrapper(queryRoleSql);
							sw.bind("cuserid", cuserid);
							sw.bind("nowtime", new UFDate());

							BaseDAO dao = new BaseDAO();
							List<String> rolePKList = (List<String>) dao
									.executeQuery(sw.getSql(),
											sw.getSqlParameter(),
											new ColumnListProcessor());

							if (CollectionUtils.isNotEmpty(rolePKList))
								rolePKResult.addAll(rolePKList);

							return rolePKResult;
						}

					});
			return rolePKResult;
		} catch (Exception ex) {
			throw new BusinessException(ex.getMessage());
		}
	}

	@SuppressWarnings("unchecked")
	private List<ResponsibilityVO> fetchResponsibilityRelateRoles(
			HashSet<String> rolePKResult) throws BusinessException {
		try {
			String[] rolePKs = rolePKResult.toArray(new String[0]);

			InSqlBatchCaller respCaller = new InSqlBatchCaller(rolePKs);
			List<ResponsibilityVO> respResultList = (List<ResponsibilityVO>) respCaller
					.execute(new IInSqlBatchCallBack() {
						List<ResponsibilityVO> respResultList = new ArrayList<ResponsibilityVO>();

						@Override
						public Object doWithInSql(String inSql)
								throws BusinessException, SQLException {
							NamedParamUtil npu = new NamedParamUtil();
							npu.reset();
							npu.addNamedParam("rolePKs", inSql);

							BaseDAO dao = new BaseDAO();
							List<ResponsibilityVO> respList = (List<ResponsibilityVO>) dao
									.retrieveByClause(
											ResponsibilityVO.class,
											npu.format(PubServiceSqlUtils.RESP_OWNEDBY_ROLES_COND));

							if (CollectionUtils.isNotEmpty(respList))
								respResultList.addAll(respList);

							return respResultList;
						}
					});
			return respResultList;
		} catch (Exception ex) {
			throw new BusinessException(ex.getMessage());
		}
	}

	@Override
	public UserVO[] getUsersOwnedRespAndOrgsPerm(String[] respPKs,
			final String[] orgPKs) throws BusinessException {
		if (ArrayUtils.isEmpty(respPKs))
			return null;
		
		List<String> roleResult = RolePermBaseQuery
				.fetchRolePKlistByRespAndOrg(respPKs, orgPKs);

		if (CollectionUtils.isEmpty(roleResult))
			roleResult = new ArrayList<String>();

		final String[] rolePKs = roleResult.toArray(new String[0]);

		List<UserVO> userResult = getUserListByRoles(rolePKs);
		if(userResult==null){
			userResult=new ArrayList<UserVO>();
		}
		
		//TODO
		//加入组织规则计算出的用户
		List<String> allRoleResult = RolePermBaseQuery
				.fetchRolePKlistByRespAndOrg(respPKs, null);
		final String[] allRolePKs = allRoleResult.toArray(new String[0]);

		List<UserVO> allUserResult = getUserListByRoles(allRolePKs);
		String pk_group = InvocationInfoProxy.getInstance().getGroupId();
		
		if(!CollectionUtils.isEmpty(allUserResult)&&!CollectionUtils.isEmpty(userResult)){
			allUserResult.removeAll(userResult);
		}
		if(!CollectionUtils.isEmpty(allUserResult)){
			for(UserVO user:allUserResult){
				Map<String, Map<String, Set<String>>> roleWithRuleOrgs=getRuleOrgs(user.getCuserid(),pk_group);	
				if(roleWithRuleOrgs!=null){
					a:for(String role:roleWithRuleOrgs.keySet()){
						for(String org:orgPKs){
							Map<String, Set<String>>ruleOrgs=roleWithRuleOrgs.get(role);
							if(!ruleOrgs.isEmpty()){
								for(String ruleid:ruleOrgs.keySet()){
									if(ruleOrgs.get(ruleid).contains(org)){
											userResult.add(user);
										break a;
									}
								}
							}
						}
					}
				}
			}
		}
		
		UserVO[] uo = queryUserWithInOrgPermission(orgPKs);
		UserVO[] ur = queryUserWithInRespPermission(respPKs);

		Map<String, UserVO> m2 = new HashMap<String, UserVO>();
		Map<String, UserVO> m3 = new HashMap<String, UserVO>();
		if (uo != null) {
			for (UserVO u : uo)
				m2.put(u.getCuserid(), u);
		}
		if (ur != null) {
			for (UserVO u : ur)
				if (m2.containsKey(u.getCuserid()))
					m3.put(u.getCuserid(), u);
		}
		if (userResult != null) {
			for (UserVO u : userResult)
				m3.put(u.getCuserid(), u);
		}
		return CollectionUtils.isEmpty(m3.keySet()) ? null : m3.values()
				.toArray(new UserVO[0]);
	}

	@Override
	public UserVO[] getUsersOwnedRespPerm(String[] respPKs)
			throws BusinessException {
		if (ArrayUtils.isEmpty(respPKs))
			return null;

		List<String> roleResult = RolePermBaseQuery
				.queryRolePKlistByInRespAndInOrg(respPKs, null);

		if (CollectionUtils.isEmpty(roleResult))
			roleResult = new ArrayList<String>();

		final String[] rolePKs = roleResult.toArray(new String[0]);

		List<UserVO> userResult = getUserListByRoles(rolePKs);

		UserVO[] ur = queryUserWithInRespPermission(respPKs);

		Map<String, UserVO> userMap = new HashMap<String, UserVO>();

		if (ur != null) {
			for (UserVO u : ur)
				userMap.put(u.getCuserid(), u);
		}

		if (userResult != null) {
			for (UserVO u : userResult)
				userMap.put(u.getCuserid(), u);
		}
		return CollectionUtils.isEmpty(userMap.keySet()) ? null : userMap
				.values().toArray(new UserVO[0]);
	}

	@SuppressWarnings("unchecked")
	private UserVO[] queryUserWithInOrgPermission(String... orgPKs)
			throws BusinessException {
		if (ArrayUtils.isEmpty(orgPKs))
			return null;

		try {
			InSqlBatchCaller caller = new InSqlBatchCaller(orgPKs);
			List<UserVO> resultList = (List<UserVO>) caller
					.execute(new IInSqlBatchCallBack() {
						List<UserVO> resultList = new ArrayList<UserVO>();

						@Override
						public Object doWithInSql(String inSql)
								throws BusinessException, SQLException {
							String pk_group = InvocationInfoProxy.getInstance()
									.getGroupId();
							NamedParamUtil npu = new NamedParamUtil();
							npu.addNamedParam("pk_group", pk_group);
							npu.addNamedParam("orgs", inSql);

							String condition = npu
									.format(PubServiceSqlUtils.USERS_WITHIN_ORGPERM_CONDITION);

							BaseDAO dao = new BaseDAO();

							List<UserVO> userList = (List<UserVO>) dao
									.retrieveByClause(UserVO.class, condition);

							if (CollectionUtils.isNotEmpty(userList))
								resultList.addAll(userList);

							return resultList;
						}
					});

			return CollectionUtils.isEmpty(resultList) ? null : resultList
					.toArray(new UserVO[0]);
		} catch (Exception e) {
			throw new BusinessException(e);
		}
	}

	@SuppressWarnings("unchecked")
	private UserVO[] queryUserWithInRespPermission(String... respPKs)
			throws BusinessException {
		if (ArrayUtils.isEmpty(respPKs))
			return null;

		try {
			InSqlBatchCaller caller = new InSqlBatchCaller(respPKs);
			List<UserVO> resultList = (List<UserVO>) caller
					.execute(new IInSqlBatchCallBack() {
						List<UserVO> resultList = new ArrayList<UserVO>();

						@Override
						public Object doWithInSql(String inSql)
								throws BusinessException, SQLException {
							String pk_group = InvocationInfoProxy.getInstance()
									.getGroupId();
							NamedParamUtil npu = new NamedParamUtil();
							npu.addNamedParam("pk_group", pk_group);
							npu.addNamedParam("resps", inSql);

							String condition = npu
									.format(PubServiceSqlUtils.USERS_WITHIN_RESPPERM_CONDITION);

							BaseDAO dao = new BaseDAO();

							List<UserVO> userList = (List<UserVO>) dao
									.retrieveByClause(UserVO.class, condition);

							if (CollectionUtils.isNotEmpty(userList))
								resultList.addAll(userList);

							return resultList;
						}
					});

			return CollectionUtils.isEmpty(resultList) ? null : resultList
					.toArray(new UserVO[0]);
		} catch (Exception e) {
			throw new BusinessException(e);
		}
	}

	@SuppressWarnings("unchecked")
	private List<UserVO> getUserListByRoles(final String[] rolePKs)
			throws BusinessException {
		try {
			InSqlBatchCaller userCaller = new InSqlBatchCaller(rolePKs);
			List<UserVO> userResult = (List<UserVO>) userCaller
					.execute(new IInSqlBatchCallBack() {
						List<UserVO> userResult = new ArrayList<UserVO>();

						@Override
						public Object doWithInSql(String inSql)
								throws BusinessException, SQLException {
							NamedParamUtil npu = new NamedParamUtil();
							npu.addNamedParam("rolePKs", inSql);
							npu.addNamedParam("nowtime", new UFDate());

							BaseDAO dao = new BaseDAO();
							List<UserVO> userList = (List<UserVO>) dao.retrieveByClause(
									UserVO.class,
									npu.format(PubServiceSqlUtils.OWNED_ROLESPERM_USERS_COND));

							if (CollectionUtils.isNotEmpty(userList))
								userResult.addAll(userList);

							return userResult;
						}

					});
			return userResult;
		} catch (Exception ex) {
			throw new BusinessException(ex.getMessage());
		}
	}

	@SuppressWarnings("unchecked")
	@Override
	public UserVO[] getUsersByPKs(String[] userPKs) throws BusinessException {
		if (ArrayUtils.isEmpty(userPKs))
			return null;

		InSqlBatchCaller caller = new InSqlBatchCaller(userPKs);
		try {
			List<UserVO> userList = (List<UserVO>) caller
					.execute(new IInSqlBatchCallBack() {
						List<UserVO> userResult = new ArrayList<UserVO>();

						@Override
						public Object doWithInSql(String inSql)
								throws BusinessException, SQLException {
							String cond = UserVO.CUSERID + " in " + inSql;
							BaseDAO dao = new BaseDAO();
							Collection<UserVO> userColl = dao.retrieveByClause(
									UserVO.class, cond);

							userResult.addAll(userColl);

							return userResult;
						}

					});

			return CollectionUtils.isEmpty(userList) ? null : userList
					.toArray(new UserVO[0]);
		} catch (SQLException e) {
			throw new BusinessException(e.getMessage());
		}
	}

	@SuppressWarnings("unchecked")
	@Override
	public Map<String, UserVO> getUsersRelatedWithCustomer(String[] userPKs)
			throws BusinessException {

		try {
			List<UserVO> userList = null;

			if (ArrayUtils.isEmpty(userPKs)) {
				String cond = " base_doc_type = ? and pk_base_doc != '~' ";
				SQLParameter sp = new SQLParameter();
				sp.addParam(UserIdentityTypeEnumFactory.TYPE_CUSTOMER);

				BaseDAO dao = new BaseDAO();
				userList = (List<UserVO>) dao.retrieveByClause(UserVO.class,
						cond, sp);

			} else {
				InSqlBatchCaller caller = new InSqlBatchCaller(userPKs);
				userList = (List<UserVO>) caller
						.execute(new IInSqlBatchCallBack() {
							List<UserVO> userResult = new ArrayList<UserVO>();

							@Override
							public Object doWithInSql(String inSql)
									throws BusinessException, SQLException {
								String cond = " base_doc_type = ? and pk_base_doc != '~' and "
										+ UserVO.CUSERID + " in " + inSql;
								SQLParameter sp = new SQLParameter();
								sp.addParam(UserIdentityTypeEnumFactory.TYPE_CUSTOMER);

								BaseDAO dao = new BaseDAO();
								Collection<UserVO> userColl = dao
										.retrieveByClause(UserVO.class, cond,
												sp);

								userResult.addAll(userColl);

								return userResult;
							}

						});
			}

			Map<String, UserVO> pk_user_map = null;
			if (CollectionUtils.isNotEmpty(userList))
				pk_user_map = RbacPubUtil.getHashMapVO(userList
						.toArray(new UserVO[0]));

			return pk_user_map;
		} catch (SQLException e) {
			throw new BusinessException(e.getMessage());
		}
	}

	@Override
	public boolean resetUserPassWord(String cuserid) throws BusinessException {
		try {
			IUserPasswordManage upwdManage = NCLocator.getInstance().lookup(
					IUserPasswordManage.class);
			upwdManage.resetUserPassWord(cuserid);

			return true;
		} catch (Exception ex) {
			return false;
		}
	}

	@Override
	public void updateUserPassWord(String cuserid, String oldPwd, String newPwd)
			throws BusinessException {
		if (StringUtils.isBlank(oldPwd))
			throw new BusinessException(
					IUserPubConstants.getOldPasswordNullMsg());
		if (StringUtils.isBlank(newPwd))
			throw new BusinessException(
					IUserPubConstants.getNewPasswordNullMsg());
		if (StringUtils.equals(oldPwd, newPwd))
			throw new BusinessException(
					IUserPubConstants.getNewAndOldPAsswordNotSameMsg());

		IUserManageQuery userQry = NCLocator.getInstance().lookup(
				IUserManageQuery.class);
		UserVO oldUser = userQry.getUser(cuserid);

		// 旧密码加密并与之前 用户当前密码比较 进行校验
		if (!RbacUserPwdUtil.checkUserPassword(oldUser, oldPwd))
			throw new BusinessException(
					IUserPubConstants.getOldPasswordErrorMsg());

		IUserPasswordManage upwdManage = NCLocator.getInstance().lookup(
				IUserPasswordManage.class);
		upwdManage.changeUserPassWord(oldUser, newPwd);
	}

	@SuppressWarnings("unchecked")
	@Override
	public UserVO[] queryUsersOwnedOrgPermission(String... orgPKs)
			throws BusinessException {
		if (ArrayUtils.isEmpty(orgPKs))
			return null;

		if (orgPKs.length == 1) {
			BaseDAO dao = new BaseDAO();
			SqlWrapper sw = new SqlWrapper(
					PubServiceSqlUtils.USERS_OWNED_SINGLEORG_COND);
			sw.bind("pk_org", orgPKs[0]);
			sw.bind("nowtime", new UFDateTime());

			Collection<UserVO> userColl = dao.retrieveByClause(UserVO.class,
					sw.getSql(), sw.getSqlParameter());

			return CollectionUtils.isEmpty(userColl) ? null : userColl
					.toArray(new UserVO[0]);
		} else {

			String pk_group = InvocationInfoProxy.getInstance().getGroupId();

			List<UserVO> userResult = getUserListByGroupAndOrgs(pk_group,
					orgPKs);

			return CollectionUtils.isEmpty(userResult) ? null : userResult
					.toArray(new UserVO[0]);
		}
	}

	@SuppressWarnings("unchecked")
	private List<UserVO> getUserListByGroupAndOrgs(final String pk_group,
			String... orgPKs) throws BusinessException {
		try {
			InSqlBatchCaller userCaller = new InSqlBatchCaller(orgPKs);
			List<UserVO> userResult = (List<UserVO>) userCaller
					.execute(new IInSqlBatchCallBack() {
						List<UserVO> userResult = new ArrayList<UserVO>();

						@Override
						public Object doWithInSql(String inSql)
								throws BusinessException, SQLException {
							NamedParamUtil npu = new NamedParamUtil();
							npu.addNamedParam("pk_group", pk_group);
							npu.addNamedParam("orgs", inSql);

							String userOwnPermCond = npu
									.format(PubServiceSqlUtils.USERS_OWNED_MANYORG_COND);

							SqlWrapper sw = new SqlWrapper(userOwnPermCond);
							sw.bind("nowtime", new UFDateTime());

							BaseDAO dao = new BaseDAO();
							List<UserVO> userList = (List<UserVO>) dao
									.retrieveByClause(UserVO.class,
											sw.getSql(), sw.getSqlParameter());
							if (CollectionUtils.isNotEmpty(userList))
								userResult.addAll(userList);

							return userResult;
						}

					});
			return userResult;
		} catch (Exception ex) {
			throw new BusinessException(ex.getMessage());
		}
	}

	/**
	 * @author liuxing0
	 */
	@Override
	public void updateUserEmail(String cuserid, String email, String password)
			throws BusinessException {
		BaseDAO dao = new BaseDAO();
		UserVO userVO = (UserVO) dao.retrieveByPK(UserVO.class, cuserid);
		BDPKLockUtil.lockSuperVO(userVO);
		validate(userVO, email, password);

		UserVO newVO = (UserVO) userVO.clone();
		newVO.setEmail(email);
		// 事件前通知
		BDCommonEventUtil eventUtil = new BDCommonEventUtil(
				IBDMetaDataIDConstBasic.USER);
		eventUtil.setOldObjs(new Object[] { userVO });
		eventUtil.dispatchUpdateBeforeEvent(new Object[] { newVO });
		// 数据库更新
		dao.updateVO(newVO);
		newVO = (UserVO) dao.retrieveByPK(UserVO.class, newVO.getPrimaryKey());
		// 事件后通知
		eventUtil.setOldObjs(new Object[] { userVO });
		eventUtil.dispatchUpdateBeforeEvent(new Object[] { newVO });
	}

	private void validate(UserVO userVO, String email, String password)
			throws BusinessException {
		checkPassword(password, userVO);
		checkEmailForm(email);
	}

	private void checkPassword(String password, UserVO userVO)
			throws BusinessException {
		if (!(userVO.getUser_password().equals(password))) {
			throw new BusinessException(NCLangResOnserver.getInstance()
					.getStrByID("sfapp", "MailBingPage-00011")/* 您输入的密码不正确 */,
					IUserPubConstants.PASSWORG_ERROR_CODE);
		}
	}

	private void checkEmailForm(String email) throws BusinessException {
		boolean flag = false;
		try {
			String check = "^([a-z0-9A-Z]+[_-|\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$";
			Pattern regex = Pattern.compile(check);
			Matcher matcher = regex.matcher(email);
			flag = matcher.matches();
		} catch (Exception e) {
			flag = false;
		}
		if (!flag) {
			throw new BusinessException(
					NCLangResOnserver.getInstance().getStrByID("sfapp",
							"MailBingPage-00012") /* 您输入的有邮箱不正确 */,
					IUserPubConstants.EMAIL_FORM_ERROR_CODE);
		}
	}
}

你可能感兴趣的:(NC)