yunsu/cloud-socket/src/com/js/kbt/controller/WeiXinUserInfoController.java

package com.js.kbt.controller;

import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

import com.alibaba.fastjson.JSONObject;
import com.js.kbt.mapper.MouldDownPacketMapper;
import com.js.kbt.mapper.TbUserMapper;
import com.js.kbt.model.MouldDownPacket;
import com.js.kbt.model.MouldDownPacketExample;
import com.js.kbt.model.PacketMessage;
import com.js.kbt.model.TbUser;
import com.js.kbt.model.TbUserExample;
import com.js.kbt.util.MD5Util;
import com.js.kbt.util.ProjectConst;
import com.js.kbt.util.WeiXinUtils;
import com.js.kbt.util.WeixinPayConstants;

/**
 * @author seyason
 * @create 2019-08-08
 * @desc 获取用户微信openid，绑定
 **/
@Controller
public class WeiXinUserInfoController {

	@Autowired
	private HttpServletRequest request;
	@Resource(name = "tbUserMapper")
	private TbUserMapper tbUserMapper;
	@Resource(name = "packetMessage")
	private PacketMessage packetMessage;
	@Resource(name = "mouldDownPacketMapper")
	private MouldDownPacketMapper mouldDownPacketMapper;

//	@Autowired
//	private WeiXinPlatformService weiXinPlatformService;
	Logger log = Logger.getLogger(WeiXinUserInfoController.class);	

	@ResponseBody
	@RequestMapping("/checkAccountStatus")
	public void checkAccountStatus(@RequestParam String openid, HttpServletResponse response) throws IOException{
		HttpRespMsg msg = new HttpRespMsg();
		TbUserExample example = new TbUserExample();
		example.createCriteria().andOpenidEqualTo(openid);
		if (tbUserMapper.countByExample(example) > 0) {
			TbUser user = tbUserMapper.selectByExample(example).get(0);
			msg.data = user.getAccount();
		} else {
			msg.setError("没有找到相应账号");
		}
		response.setContentType("application/json");
		response.setCharacterEncoding("UTF-8");
		response.getWriter().println(msg.toJSONStr());
	}

	@RequestMapping("/getWeiXinOpenid")
	public ModelAndView getWeiXinOpenid(@RequestParam(required = false) String code) {
		log.info("============!!!!!进入getWeiXinOpenid==========");
		ModelAndView modelAndView = new ModelAndView("bind_weixin");
		/**
		 * 进行获取openId，必须的一个参数，这个是当进行了授权页面的时候，再重定向了我们自己的一个页面的时候，
		 * 会在request页面中，新增这个字段信息，要结合这个ProjectConst.Get_WEIXINPAGE_Code这个常量思考
		 */
		try {
			// 得到当前用户的信息(具体信息就看weixinUser这个javabean)
			WeiXinUser weiXinUser = getTheCode(request.getSession(), code);
			// 如果没有，进行注册
			if (weiXinUser != null) {
				System.out.println("openid=" + weiXinUser.getOpenId());
				String openId = weiXinUser.getOpenId();
				modelAndView.addObject("openid", openId);
				modelAndView.addObject("isFail", false);
			} else {
				modelAndView.addObject("isFail", true);
			}
		} catch (Exception e) {
			e.printStackTrace();
			modelAndView.addObject("isFail", true);
		}
		return modelAndView;
	}
	
	
	/**
	 * 将openid和账号进行绑定，验证密码
	 * @param openid
	 * @param account
	 * @param pwd
	 * @param response
	 */
	@RequestMapping("/bindAccount")
	public void bindAccount(@RequestParam String openid,@RequestParam String account, @RequestParam String pwd,
			HttpServletResponse response
			) {
		HttpRespMsg msg = new HttpRespMsg();
		
		TbUserExample example = new TbUserExample();
		example.createCriteria().andAccountEqualTo(account).andPasswordEqualTo(MD5Util.getPassword(pwd));
		if (tbUserMapper.countByExample(example) > 0) {
			TbUser user = tbUserMapper.selectByExample(example).get(0);
			user.setOpenid(openid);
			tbUserMapper.updateByPrimaryKeySelective(user);
		} else {
			msg.setError("账号密码错误");
		}
		response.setContentType("application/json");
		response.setCharacterEncoding("UTF-8");
		try {
			response.getWriter().println(msg.toJSONStr());
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	

	/**
	 * 获取用户的openId
	 * 
	 * @param session
	 * @param code
	 * @return 返回封装的微信用户的对象
	 */
	private WeiXinUser getTheCode(HttpSession session, String code) {
		Map<String, String> authInfo = new HashMap<>();
		String openId = "";
		if (code != null) {
			// 调用根据用户的code得到需要的授权信息
			authInfo = getAuthInfo(code);
			// 获取到openId
			openId = authInfo.get("Openid");
		}
		System.out.println("获取到微信openid==" + openId);
		// 获取基础刷新的接口访问凭证（目前还没明白为什么用authInfo.get("AccessToken");这里面的access_token就不行）
		String accessToken = authInfo.get("AccessToken");
		// 获取到微信用户的信息
		WeiXinUser userinfo = getUserInfo(accessToken, openId);
		if (userinfo == null && openId != null && !openId.equals("")) {
			userinfo = new WeiXinUser();
			userinfo.setOpenId(openId);
		}
		return userinfo;
	}

	public WeiXinUser getUserInfo(String accessToken, String openId) {
		WeiXinUser weixinUserInfo = null;
		// 拼接获取用户信息接口的请求地址
		// String requestUrl = ProjectConst.GET_WEIXIN_USER_URL.replace("ACCESS_TOKEN",
		// accessToken).replace(
		// "OPENID", openId);
		String requestUrl = ProjectConst.GetPageUsersUrl.replace("ACCESS_TOKEN", accessToken).replace("OPENID", openId);
		// 获取用户信息(返回的是Json格式内容)
		JSONObject jsonObject = WeiXinUtils.doGetStr(requestUrl);

		if (null != jsonObject) {
			try {
				// 封装获取到的用户信息
				weixinUserInfo = new WeiXinUser();
				// 用户的标识
				weixinUserInfo.setOpenId(jsonObject.getString("openid"));
				// 昵称
//				weixinUserInfo.setNickname(EmojiHttpServletRequestWraper.filterEmoji(jsonObject.getString("nickname")));
				// 用户的性别（1是男性，2是女性，0是未知）
//				if (jsonObject.containsKey("sex")) {
//					weixinUserInfo.setSex(jsonObject.getInteger("sex"));
//				}

				// 用户所在国家
				weixinUserInfo.setCountry(jsonObject.getString("country"));
				// 用户所在省份
				weixinUserInfo.setProvince(jsonObject.getString("province"));
				// 用户所在城市
				weixinUserInfo.setCity(jsonObject.getString("city"));
				// 用户头像
				weixinUserInfo.setHeadImgUrl(jsonObject.getString("headimgurl"));
			} catch (Exception e) {
				if (0 == weixinUserInfo.getSubscribe()) {
					System.out.println("用户并没有关注本公众号");
				} else {
					int errorCode = jsonObject.getInteger("errcode");
					String errorMsg = jsonObject.getString("errmsg");
					System.out.println("由于" + errorCode + "错误码；错误信息为：" + errorMsg + "；导致获取用户信息失败");
				}
			}
		}
		return weixinUserInfo;
	}
	
	/**
	 * 进行用户授权，获取到需要的授权字段，比如openId
	 * 
	 * @param code
	 *            识别得到用户id必须的一个值 得到网页授权凭证和用户id
	 * @return
	 */
	public Map<String, String> oauth2GetOpenid(String code) {
		// 自己的配置appid（公众号进行查阅）
		String appid = WeixinPayConstants.appid;
		// 自己的配置APPSECRET;（公众号进行查阅）
		String appsecret = WeixinPayConstants.appsecret;
		// 拼接用户授权接口信息
		String requestUrl = ProjectConst.GET_WEBAUTH_URL.replace("APPID", appid).replace("SECRET", appsecret)
				.replace("CODE", code);
		// 存储获取到的授权字段信息
		Map<String, String> result = new HashMap<String, String>();
		try {
			JSONObject OpenidJSONO = WeiXinUtils.doGetStr(requestUrl);
			// OpenidJSONO可以得到的内容：access_token expires_in refresh_token openid scope
			String Openid = String.valueOf(OpenidJSONO.get("openid"));
			String AccessToken = String.valueOf(OpenidJSONO.get("access_token"));
			// 用户保存的作用域
			String Scope = String.valueOf(OpenidJSONO.get("scope"));
			String refresh_token = String.valueOf(OpenidJSONO.get("refresh_token"));
			result.put("Openid", Openid);
			result.put("AccessToken", AccessToken);
			result.put("scope", Scope);
			result.put("refresh_token", refresh_token);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return result;
	}

	/**
	 * 获取到微信用户的唯一的OpendID
	 * 
	 * @param code
	 *            这是要获取OpendId的必须的一个参数
	 * @return
	 */
	public Map<String, String> getAuthInfo(String code) {
		// 进行授权验证，获取到OpenID字段等信息
		Map<String, String> result = oauth2GetOpenid(code);
		// 从这里可以得到用户openid
		String openId = result.get("Openid");

		return result;
	}
	
	/**
	 * 云平台下行配置数据包接口
	 * lowPowerLimit 低电量报警限值：（1 字节,十六进制）如：1e
	 * hotAlarmLimit 热报警限值：（1 字节,十六进制）如：50
	 * equipmentNo 设备编号
	 */
	@RequestMapping("/setPacket")
	public void bindAccount(HttpServletResponse response,String lowPowerLimit,String hotAlarmLimit,String equipmentNo) {
		HttpRespMsg msg = new HttpRespMsg();
		String setPacketMessage = "";
		MouldDownPacket mouldDownPacket = new MouldDownPacket();
		MouldDownPacketExample exp = new MouldDownPacketExample();
		exp.createCriteria().andEquipmentNoEqualTo(equipmentNo);
		List<MouldDownPacket> list = mouldDownPacketMapper.selectByExample(exp);
		if(list.size()>0){
			mouldDownPacket = list.get(0);
			setPacketMessage = downProcessMsg(lowPowerLimit,hotAlarmLimit);
			mouldDownPacket.setPacketStr(setPacketMessage);
			mouldDownPacket.setIsUse(0);
			mouldDownPacketMapper.updateByPrimaryKey(mouldDownPacket);
			
		}else{
			setPacketMessage = downProcessMsg(lowPowerLimit,hotAlarmLimit);
			mouldDownPacket.setEquipmentNo(equipmentNo);
			mouldDownPacket.setPacketStr(setPacketMessage);
			mouldDownPacketMapper.insertSelective(mouldDownPacket);
		}
		response.setContentType("application/json");
		response.setCharacterEncoding("UTF-8");
		try {
			response.getWriter().println(msg.toJSONStr());
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	// 下行配置数据包
		private String downProcessMsg(String lowPowerLimit,String hotAlarmLimit) {
			//"23"不解析
			if("23".equals(lowPowerLimit)){
				lowPowerLimit="24";
			}
			if("23".equals(hotAlarmLimit)){
				hotAlarmLimit="24";
			}
			String ret = "FA AF 00 07 02 1e 78 lowPowerLimit hotAlarmLimit 00 3C";
			ret.replace("lowPowerLimit", lowPowerLimit);
			ret.replace("hotAlarmLimit", hotAlarmLimit);
			ret.replaceAll(" ", "");
			//16 位 CRC 校验(低位在前；高位在后)
			int crc = reverseParseHex(ret);
			String crcString = crc + "";
			ret = ret + crcString;
			return ret;
		}
		
		/**
		 * 低位在前的16进制解析
		 * 
		 * @param rHex
		 * @return
		 */
		public static int reverseParseHex(String rHex) {
			int size = rHex.length() / 2;
			StringBuilder sb = new StringBuilder();
			for (int i = 0; i < size; i++) {
				sb.append(rHex.substring((size - i - 1) * 2, (size - i) * 2));
			}
			String str = sb.toString();
			return Integer.parseInt(str, 16);
		}
}