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.TbMouldEquipmentMapper;
import com.js.kbt.mapper.TbUserMapper;
import com.js.kbt.model.MouldDownPacket;
import com.js.kbt.model.MouldDownPacketExample;
import com.js.kbt.model.TbMouldEquipment;
import com.js.kbt.model.TbMouldEquipmentExample;
import com.js.kbt.model.TbUser;
import com.js.kbt.model.TbUserExample;
import com.js.kbt.util.CRC16Util;
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 = "mouldDownPacketMapper")
	private MouldDownPacketMapper mouldDownPacketMapper;
	@Resource
	private TbMouldEquipmentMapper tbMouldEquipmentMapper;

//	@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=31
	 * hotAlarmLimit 热报警限值：（1 字节,十六进制）如：50=80
	 * equipmentNo 设备编号（可能是多个或者一个）多个以“，”隔开传  如："123456"(单个)，"123456,456878,123589"(多个)
	 */
	@RequestMapping("/setPacket")
	public void bindAccount(HttpServletResponse response,Integer lowPowerLimit,Integer hotAlarmLimit,String equipmentNo) {
		HttpRespMsg msg = new HttpRespMsg();
		//16进制的转化
		String lowPowerLimitStr = Integer.toHexString(lowPowerLimit);
		String hotAlarmLimitStr = Integer.toHexString(hotAlarmLimit);
		System.out.println("lowPowerLimit"+lowPowerLimit+"hotAlarmLimit"+hotAlarmLimit);
		String setPacketMessage = "";
		MouldDownPacket mouldDownPacket = new MouldDownPacket();
		MouldDownPacketExample exp = new MouldDownPacketExample();
		TbMouldEquipmentExample tExp = new TbMouldEquipmentExample();
		String[] split = equipmentNo.split(",");
		for (String string : split) {
			System.out.println("进来了"+string);
			exp.createCriteria().andEquipmentNoEqualTo(string);
			tExp.createCriteria().andEquipmentNoEqualTo(string);
			TbMouldEquipment equipment = tbMouldEquipmentMapper.selectByExample(tExp).get(0);
			equipment.setHillNumber(lowPowerLimit+"%");
			equipment.setTemperature(hotAlarmLimit);
			//更新云模盒的报警温度和电量
			tbMouldEquipmentMapper.updateByPrimaryKey(equipment);
			List<MouldDownPacket> list = mouldDownPacketMapper.selectByExample(exp);
			if(list.size()>0){
				mouldDownPacket = list.get(0);
				setPacketMessage = downProcessMsg(lowPowerLimitStr,hotAlarmLimitStr);
				mouldDownPacket.setPacketStr(setPacketMessage);
				mouldDownPacket.setIsUse(0);
				mouldDownPacketMapper.updateByPrimaryKey(mouldDownPacket);
			}else{
				setPacketMessage = downProcessMsg(lowPowerLimitStr,hotAlarmLimitStr);
				mouldDownPacket.setEquipmentNo(equipmentNo);
				mouldDownPacket.setPacketStr(setPacketMessage);
				mouldDownPacketMapper.insertSelective(mouldDownPacket);
			}
			exp.clear();
			tExp.clear();
		}
		msg.data = setPacketMessage;
		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 = ret.replaceAll(" ", "");
			String crcCode = CRC16Util.getCRC(ret);
			System.out.println("ret===>"+ret);
			String lastPart = (ret + crcCode).replaceAll("23", "24").replaceAll(" ", "");
			System.out.println("lastPart===>"+lastPart);
			return lastPart;
		}
		
		/**
		 * 低位在前的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();
			System.out.println("str"+str);
			return Integer.parseInt(str, 16);
		}
		
//		public static byte[] strToByte(String data) {
//	        data = data.replace(" ", "");
//	        int len = data.length();
//	        if (!(len % 2 == 0)) {
//	        	byte[] para = new byte[]{0,0,0,0};
//	            return para;
//	        }
//	        int num = len / 2;
//	        byte[] para = new byte[num];
//	        for (int i = 0; i < num; i++) {
//	            int value = Integer.valueOf(data.substring(i * 2, 2 * (i + 1)), 16);
//	            para[i] = (byte) value;
//	        }
//	        for (byte b : para) {
//				
//			}
//	        return para;
//	    }
//		
//		private static String crc(byte str[],int len){
//		    int crc =  0xFFFF;
//		    byte data;
//		    for(int i = 0 ; i < len ; i++){
//		        data =  str[i];
//		        for(int j = 0; j < 8; j++){
//		            if ((((crc&0x8000)>>8)^(data&0x80))!=0){
//		                crc =  ((crc << 1) ^ 0x8005);
//		            }
//		            else
//		            {
//		                crc <<= 1;
//		            }
//		            data <<= 1;
//		        }
//		    }
//		    System.out.println("crc"+crc);
//		  //结果转换为16进制
//	        String result = Integer.toHexString(crc).toUpperCase();
//	        if (result.length() != 4) {
//	            StringBuffer sb = new StringBuffer("0000");
//	            result = sb.replace(4 - result.length(), 4, result).toString();
//	        }
//		    return result;  
//		}
		
		public static void main(String[] args) {
			String ret = "D5 37";
			String part = "FA AF 00 07 02 1e 78"+" 1e"+" "+"50"+" 00 3C"; 
//			byte[] strToByte = strToByte(part);
//			String crc1 = crc(part.getBytes(),strToByte.length);
//			System.out.println("crc"+crc1);
			ret = ret.replaceAll(" ", "");
			System.out.println(ret);
//			int parseInt = Integer.parseInt(ret, 16);
//			int crc = reverseParseHex(ret);
//			System.out.println(crc);
//			System.out.println(parseInt);
		}
}