微信公众号开发

class WeiXinToken(View):

    #获取微信的token并保存到redis中，设置过期时间两个小时
    def get_weixin_token(self):
        _appid = appid
        _appsecretkey = appsecretkey
        _url = "https://api.weixin.qq.com/cgi-bin/token"
        data = {"appid": _appid, "secret": _appsecretkey, "grant_type": "client_credential"}
        result = requests.get(_url, params=data)
        json_data = result.json()
        if "access_token" in json_data:
            _access_token = json_data['access_token']
            conn = redis.Redis(host='0.0.0.0',port=6379)
            conn.setex("weixin_token",7200,_access_token)
            # conn.expire("weixin_token", 7200)
            return _access_token
        else:
            logger.error("获取的微信的access_token失败，请检查id和secretkey")
            return False
    
    #检查微信token是否还有效，无效时申请新的token保存在redis并返回
    def check_refresh_weixin_token(self):
        conn = redis.Redis(host='0.0.0.0',port=6379)
        res = conn.get("weixin_token")
        if res:
            time = conn.ttl("weixin_token")
            if time < 1800:
                res = self.get_weixin_token()
                return res
            else:
                return res
        else:
            res = self.get_weixin_token()
            return res

获取微信Token

class Sign(object):
    def __init__(self,url):
        self.noncestr = "Mmciot"
        self.url = url
    #生成签名
    def get_jsapi_ticket(self):
        tokeninfo = WeiXinToken()
        _time = int(time.time())
        _access_token = tokeninfo.check_refresh_weixin_token()
        _url = "https://api.weixin.qq.com/cgi-bin/ticket/getticket"
        data = {"access_token": _access_token, "type": "jsapi", }
        result = requests.get(_url, params=data)
        json_data = result.json()
        if "ticket" in json_data:
            jsapi_ticket = json_data["ticket"]
            conn = redis.Redis(host='0.0.0.0', port=6379)
            conn.setex("jsapi_ticket", 7200, jsapi_ticket)
            conn.setex("timestamp", 7200, _time)
            return jsapi_ticket,_time
        else:
            return False

    #检查签名并获取最新签名
    def get_new_info(self):
        conn = redis.Redis(host='0.0.0.0', port=6379)
        jsapi_ticket = conn.get("jsapi_ticket")
        timestamp = conn.get("timestamp")
        if jsapi_ticket and timestamp:
            time = conn.ttl("jsapi_ticket")
            if time < 1800:
                res = self.get_jsapi_ticket()
                return jsapi_ticket,timestamp
            else:
                return jsapi_ticket,timestamp
        else:
            jsapi_ticket, timestamp = self.get_jsapi_ticket()
            return jsapi_ticket,timestamp

    #生成签名并返回对应数据
    def create_js_sign(self):
        _jsapi_ticket, _timestamp= self.get_new_info()
        _timestamp = str(_timestamp)
        # _jsapi_ticket = "sM4AOVdWfPE4DxkXGEs8VMCPGGVi4C3VM0P37wVUCFvkVAy_90u5h9nbSlYy3-Sl-HhTdfl2fzFy1AOcHKP7qg"
        # _timestamp = "1414587457"
        _noncestr = self.noncestr
        _url = self.url
        strinfo = "jsapi_ticket" + "=" + _jsapi_ticket +"&"+ "noncestr" + "=" + _noncestr + "&"+"timestamp" + "=" + _timestamp +"&"+ "url" + "=" + _url
        sha = hashlib.sha1(strinfo)
        encrypts = sha.hexdigest()
        return encrypts,_timestamp,_noncestr,

#获取openid信息
def get_wxuser(openid):
    try:
        _wxuser = WXUser.objects.get(openid_wx=openid)
        return _wxuser
    except:
        return None

#微信openid登陆
def login_with_openid(_openid, request):
    t1 = datetime.utcnow()
    _wxuser = get_wxuser(_openid)
    print "11111111111111",_wxuser
    if _wxuser:
        _mmcuser = _wxuser.mmcuser
    else:
        _mmcuser = None
    print "search database: " + str(datetime.utcnow() - t1)
    #无绑定信息，返回绑定错误，跳转绑定接口
    if _mmcuser is None:
        # no mmcuser, no binding, so ask user to input phonenumber
        rsp = HttpResponseMessageWithData(4009, "the openid cann't binduser", "openid", _openid)
        return rsp
    #有绑定信息，直接登陆。
    else:

        mmcuser_dict = {
            "user_id": _mmcuser.id,
            "username": _mmcuser.username,
            "email": _mmcuser.email,
            "temperature_unit": _mmcuser.temperature_unit,
            "create_time": _mmcuser.create_time,
            "is_show": _mmcuser.iotprofile.is_show,
            "is_manager": _mmcuser.is_manager,
            "user_right": _mmcuser.user_right,
        }
        mmcuser_dict['openid'] = _openid
        rsp = JsonResponse({
            "message": "success",
            "mmcuser": mmcuser_dict,
            "result": 200,
            "openid": _openid
        })
        rsp.set_cookie("openid", _openid)
        print "requst session"
        try:
            request.session['openid'] = _openid
        except Exception, e:
            print e
            print "request session wrong"
        print "return resp: " + str(datetime.utcnow() - t1)
        return rsp

#创建/刷新opendi
def create_openid(res):

    #print "error is None"
    _access_token = res['access_token']
    _openid = res['openid']
    _refresh_token = res['refresh_token']
    print res['scope']
    _user = WXUser.objects.filter(openid_wx=_openid).first()
    if _user == None:
        try:
            _user = WXUser.objects.create(
                openid_wx=_openid,
                access_token=_access_token,
                expired_time=int(res['expires_in']),
                refresh_token=_refresh_token,
                time_updated = datetime.now() #db thinks what i save is a utc time
            )
            dict = {
                "result": 0,
                "message": "success",
                "openid": _user.openid_wx
            }
        except Exception, e:
            print e
            dict = {
                "result": 1,
                "message": "create user failed"
            }
    else:
        print "update user"
        try:
            _user.access_token = _access_token
            _user.expired_time = int(res['expires_in'])
            _user.refresh_token = _refresh_token
            _user.time_updated = datetime.now()
            _user.save()
            dict = {
                "result": 0,
                "message": "success",
                "openid": _user.openid_wx
            }
        except Exception, e:
            print e
            dict = {
                "result": 2,
                "message": "save user failed"
            }
    return dict



#获取Openid并登陆
class GetOpenId(View):
    @csrf_exempt
    def dispatch(self, *args, **kwargs):
        return super(GetOpenId, self).dispatch(*args, **kwargs)

    def get(self,request):
        _code = request.GET.get('code')
        if _code is None:
            return error_no_info_4001()
        data = {'appid': appid, 'secret': appsecretkey, "code": _code, "grant_type": "authorization_code"}
        _url = 'https://api.weixin.qq.com/sns/oauth2/access_token'

        #向微信请求openid
        result = requests.get(_url, params=data)
        #检查请求是否成功
        _res, _error = process_response(result)

        #创建openid信息
        opendi_result = create_openid(_res)

        #创建成功
        if opendi_result["result"] == 0:

            #通过openid登录
            rsp = login_with_openid(_res['openid'], request)
            return rsp

        #创建失败
        else:
            return JsonResponse({"result":4003,"message":"create open_id invalide"})

#首次登陆绑定openid
class BindOpneid(View):
    @csrf_exempt
    def dispatch(self, *args, **kwargs):
        return super(BindOpneid, self).dispatch(*args, **kwargs)


    def post(self,request):
        json_data = json.loads(request.body)
        try:
            _mmc_user = json_data["mmc_user"]
            _mmc_pwd  = json_data["mmc_pwd"]
            _openid = json_data["openid"]
        except Exception as e:
            logger.error("获取用户信息出错")
            return error_no_info_4001()

        try:
            user_info = authenticate(username=_mmc_user,password=_mmc_pwd)
            print user_info.id
            if user_info:
                WXUser.objects.filter(openid_wx = _openid).update(mmcuser = user_info.id)
                rsp = successinfo_200()
                # rsp.set_cookie("openid", _openid)
                request.session["openid"] = _openid
                return rsp
            else:
                return wrong_info_4002()
        except Exception as e:
            logger.error("绑定微信账号出错")
            return wrong_info_4002()