jsgkj/gkaq/yjpt-java/trunk/java_src/com/jtgh/yjpt/common/Utils.java

package com.jtgh.yjpt.common;

import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.ResourceBundle;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import javax.persistence.criteria.Subquery;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.support.rowset.SqlRowSet;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

import com.jtgh.qlyg.entity.ApplyFormItem;
import com.jtgh.yjpt.common.servlet.InitServlet;
import com.jtgh.yjpt.entity.BaseEntity;
import com.jtgh.yjpt.entity.auth.UserEntity;
import com.jtgh.yjpt.entity.common.AccessoryEntity;
import com.jtgh.yjpt.entity.common.CodeEntity;
import com.jtgh.yjpt.entity.common.TaskInfoEntity;
import com.jtgh.yjpt.entity.qlyg.ApplyEntity;
import com.jtgh.yjpt.entity.qlyg.ApplyProcessEntity;
import com.jtgh.yjpt.entity.zysqbp.ZysqbpEntity;
import com.jtgh.yjpt.webService.common.AuthHandler;

import flex.messaging.FlexContext;

/**
 * 系统静态工具方法类。
 */
@Component
public abstract class Utils {

	/**
	 * 比较密码是否一致
	 * 
	 * @param pwd
	 * @param md5Pwd
	 * @return
	 */
	public static boolean pwdEquals(String pwd, String md5Pwd) {
		if (pwd == null || md5Pwd == null)
			return false;
		return md5Pwd.equals(encrypt(pwd));
	}

	/**
	 * 返回MD5加密后的密码
	 * 
	 * @param pwd
	 * @return
	 */
	public static String encrypt(String password) {
		String str = "";
		try {
			MessageDigest md = MessageDigest.getInstance("MD5");
			md.update(password.getBytes());
			byte b[] = md.digest();
			int i;
			StringBuffer buf = new StringBuffer("");
			for (int offset = 0; offset < b.length; offset++) {
				i = b[offset];
				if (i < 0)
					i += 256;
				if (i < 16)
					buf.append("0");
				buf.append(Integer.toHexString(i));
			}
			str = buf.toString();
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}
		return str;
	}

	/**
	 * 二进制流解析为字符串
	 * 
	 * @param content
	 * @return
	 */
	public static String encodeBase64(byte[] content) {
		BASE64Encoder encoder = new BASE64Encoder();
		return encoder.encode(content);
	}

	/**
	 * 字符串解析为二进制流
	 * 
	 * @param content
	 * @return
	 */
	public static byte[] decodeBase64(String content) {
		BASE64Decoder decoder = new BASE64Decoder();
		try {
			return decoder.decodeBuffer(content);
		} catch (IOException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 获取资源文件
	 * 
	 * @param bundle
	 *            包名
	 * @param key
	 * @return
	 */
	public static String getResource(String bundle, String key) {
		ResourceBundle resource = ResourceBundle.getBundle(Locale.getDefault()
				.toString() + "/" + bundle, Locale.getDefault(),
				Utils.class.getClassLoader());
		if (resource.containsKey(key))
			return resource.getString(key);
		return key;
	}

	/**
	 * 服务器端判断客户端浏览器类型(IE/FF/SF)
	 * 
	 * @param request
	 * @return
	 */
	public static String getBrowser(HttpServletRequest request) {
		String UserAgent = request.getHeader("USER-AGENT").toLowerCase();
		if (UserAgent != null) {
			if (UserAgent.indexOf("msie") >= 0)
				return "IE";
			if (UserAgent.indexOf("firefox") >= 0)
				return "FF";
			if (UserAgent.indexOf("safari") >= 0)
				return "SF";
		}
		return null;
	}

	/**
	 * 根据开始日期和时间段，得到到期日
	 * 
	 * @param startDate
	 * @param during
	 * @param type
	 *            承诺时限单位（0天/1工作日/2月/3年）
	 * @return
	 */
	public static Date getDueDate(Date startDate, Integer during, String type) {
		if (startDate == null)
			return null;
		JdbcTemplate jdbcTemplate = (JdbcTemplate) ApplicationContextHelper
				.getBean(JdbcTemplate.class);
		if (during == null)
			during = 0;
		Calendar c = Calendar.getInstance();
		c.setTime(startDate);
		if (Constants.QLYG_APPLY_PROMISE_TYPE_DAY.equals(type)) {
			// 按天计算
			c.add(Calendar.DATE, during);
		} else if (Constants.QLYG_APPLY_PROMISE_TYPE_WORKING_DAY.equals(type)) {
			// 按工作日计算
			String sql = "SELECT 1 FROM T_YJPT_WORKING_CALENDAR WHERE WORKING_DATE=? AND IS_WORKING=?";
			SimpleDateFormat sf = new SimpleDateFormat("yyyyMMdd");
			while (during > 0) {
				String date = sf.format(c.getTime());
				if (c.get(Calendar.DAY_OF_WEEK) == Calendar.SATURDAY
						|| c.get(Calendar.DAY_OF_WEEK) == Calendar.SUNDAY) {
					SqlRowSet rs = jdbcTemplate.queryForRowSet(sql, date,
							Constants.YES);
					if (rs.next()) {
						during--;
					}
					c.add(Calendar.DATE, 1);
				} else {
					SqlRowSet rs = jdbcTemplate.queryForRowSet(sql, date,
							Constants.NO);
					if (!rs.next()) {
						during--;
					}
					c.add(Calendar.DATE, 1);
				}
			}
		} else if (Constants.QLYG_APPLY_PROMISE_TYPE_MONTH.equals(type)) {
			// 按月计算
			c.add(Calendar.MONTH, during);
		} else if (Constants.QLYG_APPLY_PROMISE_TYPE_YEAR.equals(type)) {
			// 按年计算
			c.add(Calendar.YEAR, during);
		}
		return c.getTime();
	}

	/**
	 * 根据开始日期和时间段，得到预警日期4/5
	 * 
	 * @param startDate
	 * @param during
	 * @param type
	 *            承诺时限单位（0天/1工作日/2月/3年）
	 * @return
	 */
	public static Date getWarnDate(Date startDate, Integer during, String type) {
		if (startDate == null)
			return null;
		if (during == null)
			during = 0;
		during = BigDecimal.valueOf(during * 0.8)
				.setScale(0, RoundingMode.CEILING).intValue();
		return getDueDate(startDate, during, type);
	}

	/**
	 * 根据配置文件设置办件信息
	 * 
	 * @param entity
	 * @param processKey
	 */
	public static void setApplyProperties(ApplyEntity entity, String processKey) {
		HashMap<String, Object> applyMap = GlobalData.qlygApplyMap
				.get(processKey);
		if (applyMap == null)
			return;
		Iterator<String> it = applyMap.keySet().iterator();
		while (it.hasNext()) {
			String key = it.next();
			try {
				ApplyEntity.class.getMethod(
						"set" + key.toUpperCase().substring(0, 1)
								+ key.substring(1),
						applyMap.get(key).getClass()).invoke(entity,
						applyMap.get(key));
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		String orgId = Utils.getCurrentUser().getSzd().getByzd4();
		// 部门编码
		entity.setOrgId(orgId + "JT");
		// 权力编码前面10位的部门编号是所在地的备用字段4
		if (!StringUtils.isEmpty(entity.getItemId())) {
			entity.setItemId(orgId + "JT-" + entity.getItemId());
		}
		// 办理处室使用所在地的备用字段5
		entity.setDepartment(getCurrentUser().getSzd().getByzd5());
	}

	/**
	 * 根据配置文件设置办件过程信息
	 * 
	 * @param entity
	 * @param processKey
	 */
	public static void setApplyItemProperties(ApplyProcessEntity entity,
			String processKey, String taskKey) {
		HashMap<String, HashMap<String, Object>> applyMap = GlobalData.qlygApplyItemMap
				.get(processKey);
		if (applyMap == null)
			return;
		HashMap<String, Object> applyItemMap = applyMap.get(taskKey);
		if (applyItemMap == null)
			return;
		Iterator<String> it = applyItemMap.keySet().iterator();
		while (it.hasNext()) {
			String key = it.next();
			try {
				ApplyProcessEntity.class.getMethod(
						"set" + key.toUpperCase().substring(0, 1)
								+ key.substring(1),
						applyItemMap.get(key).getClass()).invoke(entity,
						applyItemMap.get(key));
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 根据配置文件生成办件基本信息form
	 * 
	 * @param entity
	 * @param processKey
	 * @return
	 */
	public static String getApplyForm(BaseEntity<?> entity, String processKey) {
		StringBuffer sb = new StringBuffer();
		sb.append("<?XML VERSION=\"1.0\" ENCODING=\"GBK\"?><FORMDATA>");
		if (processKey != null
				&& GlobalData.qlygApplyFormMap.get(processKey) != null) {
			List<ApplyFormItem> list = (List<ApplyFormItem>) GlobalData.qlygApplyFormMap
					.get(processKey);
			if (list != null && list.size() > 0) {
				for (ApplyFormItem formItem : list) {
					sb.append("<DATA>");
					sb.append("<KEY>");
					sb.append(formItem.getKey());
					sb.append("</KEY>");
					sb.append("<NAME>");
					sb.append(formItem.getName());
					sb.append("</NAME>");
					sb.append("<VALUE>");
					try {
						if (formItem.getId() != null) {
							Object parentObj = entity;
							String[] props = formItem.getId().split("\\.");
							for (String prop : props) {
								Object obj = parentObj
										.getClass()
										.getMethod(
												"get"
														+ prop.toUpperCase()
																.substring(0, 1)
														+ prop.substring(1))
										.invoke(parentObj);
								parentObj = obj;
								if (parentObj == null) {
									break;
								}
							}
							if (parentObj == null) {
								// 空值
							} else if ("date".equals(formItem.getType())) {
								Date d = (Date) parentObj;
								sb.append(new SimpleDateFormat(
										"yyyy-MM-dd HH:mm:ss").format(d));
							} else {
								if (!StringUtils.isEmpty(formItem.getLocale())) {
									sb.append(getResource(formItem.getLocale(),
											parentObj.toString()));
								} else {
									sb.append(parentObj.toString());
								}
							}
						}
					} catch (Exception e) {
						e.printStackTrace();
					}
					sb.append("</VALUE>");
					sb.append("</DATA>");
				}
			}
		}
		sb.append("</FORMDATA>");
		return sb.toString();
	}

	/**
	 * 设置对象属性
	 * 
	 * @param obj
	 * @param params
	 * @param name
	 * @param clazz
	 */
	public static void setField(Object obj, Object params, String name,
			Class<?> clazz) {
		try {
			Field fld = clazz.getDeclaredField(name);
			int mod = fld.getModifiers();
			if (null == obj && Modifier.isStatic(mod)) {
				if (!Modifier.isFinal(mod)) {
					if (!fld.isAccessible())
						fld.setAccessible(true);
					fld.set(null, params);
				}
			} else {
				if (!fld.isAccessible())
					fld.setAccessible(true);
				fld.set(obj, params);
			}
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (NoSuchFieldException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 获取session
	 * 
	 * @return
	 */
	public static HttpSession getSession() {
		if (FlexContext.getHttpRequest() != null) {
			HttpSession session = FlexContext.getHttpRequest().getSession();
			// System.out.println("Flex session id:" + session.getId());
			// flex客户端取session
			return session;
		}
		if (RequestContextHolder.getRequestAttributes() != null) {
			HttpSession session = ((ServletRequestAttributes) RequestContextHolder
					.getRequestAttributes()).getRequest().getSession();
			// System.out.println("Http session id:" + session.getId());
			return session;
		}
		return null;
	}

	public static Long JunitUserId = 1l;

	/**
	 * 获取当前登录人
	 * 
	 * @return
	 */
	public static UserEntity getCurrentUser() {
		if (GlobalData.isJunit) {
			UserEntity testUser = new UserEntity();
			testUser.setId(JunitUserId);
			testUser.setCode("user_junit");
			testUser.setName("junit用户");
			return testUser;
		}
		HttpSession session = getSession();
		if (session == null) {
			if (AuthHandler.getCurrentUser() != null) {
				return AuthHandler.getCurrentUser();
			}
			return null;
		}
		Object user = session.getAttribute(GlobalData.USER_SESSION_KEY);
		return (UserEntity) user;
	}

	/**
	 * WebService登录用户
	 * 
	 * @return
	 */
	public static UserEntity getWebServiceUser() {
		if (AuthHandler.getCurrentUser() != null) {
			return AuthHandler.getCurrentUser();
		}
		return null;
	}

	/**
	 * 获取当前登录人姓名
	 * 
	 * @return
	 */
	public static String getCurrentUserCode() {
		HttpSession session = getSession();
		if (session != null) {
			Object user = session.getAttribute(GlobalData.USER_SESSION_KEY);
			if (user != null)
				return ((UserEntity) user).getCode();
		}
		return "";
	}

	/**
	 * 获取当前登录人姓名
	 * 
	 * @return
	 */
	public static String getCurrentUserName() {
		HttpSession session = getSession();
		if (session != null) {
			Object user = session.getAttribute(GlobalData.USER_SESSION_KEY);
			if (user != null)
				return ((UserEntity) user).getName();
		}
		return "";
	}

	/**
	 * 根据所属区域代码获得webservice的ip
	 * 
	 * @param ssqyId
	 * @return
	 */
	public static String getWsIpBySsqy(Long ssqyId) {
		if (ssqyId == null)
			return "";
		String wsIp = "";
		if (InitServlet.groupcodeMap.get(Constants.GROUP_CODE_SZD_WS_IP) != null) {
			List<CodeEntity> ips = InitServlet.groupcodeMap
					.get(Constants.GROUP_CODE_SZD_WS_IP);
			for (CodeEntity ip : ips) {
				if (ip.getParent() != null
						&& ssqyId.toString().indexOf(
								ip.getParent().getId().toString()) == 0) {
					wsIp = ip.getCode();
					break;
				}
			}
		}
		return wsIp;
	}

	/**
	 * 根据所属区域代码获得webservice的port
	 * 
	 * @param ssqyId
	 * @return
	 */
	public static String getWsPortBySsqy(Long ssqyId) {
		if (ssqyId == null)
			return "";
		String wsPort = "";
		if (InitServlet.groupcodeMap.get(Constants.GROUP_CODE_SZD_WS_PORT) != null) {
			List<CodeEntity> ports = InitServlet.groupcodeMap
					.get(Constants.GROUP_CODE_SZD_WS_PORT);
			for (CodeEntity port : ports) {
				if (port.getParent() != null
						&& ssqyId.toString().indexOf(
								port.getParent().getId().toString()) == 0) {
					wsPort = port.getCode();
					break;
				}
			}
		}
		return wsPort;
	}

	/**
	 * 返回当前角色的上级角色
	 * 
	 * @param currRole
	 * @return
	 */
	public static String getParentRole(String currRole) {
		if (StringUtils.isEmpty(currRole)
				|| currRole.length() <= Constants.ROLE_LENGTH) {
			return "";
		}
		return currRole.substring(0, currRole.length() - Constants.ROLE_LENGTH);
	}

	public static List<Predicate> setWorkflowSpec(List<Predicate> list,
			CriteriaBuilder cb, CriteriaQuery<?> query,
			Root<? extends BaseEntity<?>> root, String lcStatus) {
		// 根据流程状态过滤
		if (null != lcStatus && !"".equals(lcStatus)) {
			if (String.valueOf(BaseEntity.RECORD_STATE_VALID).equals(lcStatus)
					|| String.valueOf(BaseEntity.RECORD_STATE_COMPLETED)
							.equals(lcStatus)) {
				list.add(cb.equal(root.get("recordStatus").as(String.class),
						lcStatus));
			} else {
				Subquery<TaskInfoEntity> subquery = query
						.subquery(TaskInfoEntity.class);
				Root<TaskInfoEntity> taskRoot = subquery
						.from(TaskInfoEntity.class);
				subquery.select(taskRoot);
				List<Predicate> subQueryPredicates = new ArrayList<Predicate>();
				subQueryPredicates.add(cb.equal(
						root.get("id").as(String.class), taskRoot.get("busId")
								.as(String.class)));
				subQueryPredicates.add(cb.equal(
						taskRoot.get("currName").as(String.class), lcStatus));
				subQueryPredicates.add(cb.notEqual(
						taskRoot.get("state").as(Long.class),
						BaseEntity.RECORD_STATE_COMPLETED));
				// List<Predicate> subOrList = new
				// ArrayList<Predicate>();
				// subOrList.add(cb.equal(taskRoot
				// .get("roleCode").as(String.class),
				// getCurrentRoleCode(functionId)));
				// subOrList.add(cb.equal(taskRoot
				// .get("runner").as(UserEntity.class),
				// Utils.getCurrentUser()));
				// subQueryPredicates.add(cb.or(subOrList.toArray(new
				// Predicate[] {})));
				subquery.where(subQueryPredicates.toArray(new Predicate[] {}));
				list.add(cb.exists(subquery));
			}
		}
		return list;
	}
	
	public static List<Predicate> setAuditNameSpec(List<Predicate> list,
			CriteriaBuilder cb, CriteriaQuery<?> query,
			Root<? extends BaseEntity<?>> root, String lcStatus, String name) {
		if(null != name && !"".equals(name)) {
			Subquery<TaskInfoEntity> subquery = query
					.subquery(TaskInfoEntity.class);
			Root<TaskInfoEntity> taskRoot = subquery.from(TaskInfoEntity.class);
			subquery.select(taskRoot);
			List<Predicate> subQueryPredicates = new ArrayList<Predicate>();
			subQueryPredicates.add(cb.equal(root.get("id").as(String.class),
					taskRoot.get("busId").as(String.class)));
			subQueryPredicates.add(cb.or(new Predicate[] {
					cb.equal(taskRoot.get("busKey").as(String.class),
							ZysqbpEntity.AUTO_PROCESS_DEFINITION_KEY),
					cb.equal(taskRoot.get("busKey").as(String.class),
							ZysqbpEntity.PROCESS_DEFINITION_KEY) }));
			subQueryPredicates.add(cb.like(
					taskRoot.get("auditUsername").as(String.class), "%" + name
							+ "%"));
			if (null != lcStatus && !"".equals(lcStatus)) {
				if (String.valueOf(BaseEntity.RECORD_STATE_VALID).equals(
						lcStatus)
						|| String.valueOf(BaseEntity.RECORD_STATE_COMPLETED)
								.equals(lcStatus)) {
					list.add(cb
							.equal(root.get("recordStatus").as(String.class),
									lcStatus));
				} else {
					subQueryPredicates.add(cb.notEqual(
							taskRoot.get("state").as(Long.class),
							BaseEntity.RECORD_STATE_COMPLETED));
				}
			}
			subquery.where(subQueryPredicates.toArray(new Predicate[] {}));			
			list.add(cb.exists(subquery));
		} else {
			// 根据流程状态过滤
			if (null != lcStatus && !"".equals(lcStatus)) {
				if (String.valueOf(BaseEntity.RECORD_STATE_VALID).equals(lcStatus)
						|| String.valueOf(BaseEntity.RECORD_STATE_COMPLETED)
								.equals(lcStatus)) {
					list.add(cb.equal(root.get("recordStatus").as(String.class),
							lcStatus));
				} else {
					Subquery<TaskInfoEntity> subquery = query
							.subquery(TaskInfoEntity.class);
					Root<TaskInfoEntity> taskRoot = subquery
							.from(TaskInfoEntity.class);
					subquery.select(taskRoot);
					List<Predicate> subQueryPredicates = new ArrayList<Predicate>();
					subQueryPredicates.add(cb.equal(
							root.get("id").as(String.class), taskRoot.get("busId")
									.as(String.class)));
					subQueryPredicates.add(cb.equal(
							taskRoot.get("currName").as(String.class), lcStatus));
					subQueryPredicates.add(cb.notEqual(
							taskRoot.get("state").as(Long.class),
							BaseEntity.RECORD_STATE_COMPLETED));
					subquery.where(subQueryPredicates.toArray(new Predicate[] {}));
					list.add(cb.exists(subquery));
				}
			}
		}
		return list;
	}
	

	/**
	 * 将传入的附件拼成固定格式的String返回
	 */
	public static String getWord(List<AccessoryEntity> list) {
		StringBuffer sbf = new StringBuffer();
		String str = "<?XML VERSION=\"1.0\" ENCODING=\"GBK\"?><DOCUMENTDATA>";
		sbf.append(str);
		if (list != null && list.size() > 0) {
			for (AccessoryEntity accessoryEntity : list) {
				sbf.append("<DOCUMENT>");
				sbf.append("<DOCUMENT_ID>").append(accessoryEntity.getId())
						.append("</DOCUMENT_ID>");
				sbf.append("<DOCUMENT_NAME>")
						.append(getResource("fileType", accessoryEntity
								.getType().getName()))
						.append("</DOCUMENT_NAME>");
				sbf.append("<FILE_NAME>").append(accessoryEntity.getName())
						.append("</FILE_NAME>");
				sbf.append("<FILE_CONTENT>")
						.append(encodeBase64(accessoryEntity.getContent()
								.getValue())).append("</FILE_CONTENT>");
				sbf.append("</DOCUMENT>");
			}
		}
		sbf.append("</DOCUMENTDATA>");
		return sbf.toString();
	}

	/**
	 * 该天最早的时候
	 * 
	 * @param date
	 * @return
	 */
	public static Date getDateFirstTime(Date date) {
		if (null == date) {
			return null;
		}
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.set(java.util.Calendar.HOUR_OF_DAY, 0);
		c.set(java.util.Calendar.MINUTE, 0);
		c.set(java.util.Calendar.SECOND, 0);
		return c.getTime();
	}

	/**
	 * 该天最迟的时候
	 * 
	 * @param date
	 * @return
	 */
	public static Date getDateLastTime(Date date) {
		if (null == date) {
			return null;
		}
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		c.set(java.util.Calendar.HOUR_OF_DAY, 23);
		c.set(java.util.Calendar.MINUTE, 59);
		c.set(java.util.Calendar.SECOND, 59);
		return c.getTime();
	}

	public static String getExeMsg(Throwable t) {
		StringWriter sw = new StringWriter();
		t.printStackTrace(new PrintWriter(sw));
		return sw.toString();
	}
	
	/**
	 * 判断字符是否满足某个正则表达式
	 * @param pwd
	 * @param regex
	 * @return
	 */
	public static Boolean pwdHas(String pwd, String regex)
	{
		Pattern p = Pattern.compile(regex);  	  
		Matcher m = p.matcher(pwd);  
		return m.find();
	}
}