Python OAuthHandler.get_access_token方法代码示例

# 需要导入模块: from weibopy.auth import OAuthHandler [as 别名]
# 或者: from weibopy.auth.OAuthHandler import get_access_token [as 别名]
class SinaClient:
    def __init__(self, key, secret):
        self.auth=OAuthHandler(key,secret)

    def get_auth_url(self):
        return self.auth.get_authorization_url()

    def set_access_token(self,token):
        key,secret=token.split('|')
        self.auth.setToken(key,secret)
        self.api=API(self.auth)

    def get_access_token(self):
        token=self.auth.access_token
        return token.key+'|'+token.secret

    def set_request_token(self,token):
        key,secret=token.split('|')
        self.auth.request_token=oauth.OAuthToken(key,secret)

    def get_request_token(self):
        token=self.auth.request_token
        return token.key+'|'+token.secret

    def set_verifier(self,verifier):
        self.auth.get_access_token(verifier)
        self.api=API(self.auth)

    def send_msg(self,msg,coord=None):
        lat,long=self.get_lat_long(coord)
        msg=msg.encode('utf-8')
        status=self.api.update_status(status=msg,lat=lat,long=long)
        return status

    def send_pic(self,msg,pic,coord=None):
        lat,long=self.get_lat_long(coord)
        msg=msg.encode('utf-8')
        status=self.api.upload(pic,status=msg,lat=lat,long=long)
        
        return status

    def get_timeline(self):
        return self.request(SINA_USER_TIMELINE_URL)

    def get_lat_long(self,coord):
        if not coord:
          return (None,None)

        return map(lambda x:str(x),coord)

    def get_user(self):
        return self.api.verify_credentials()

# 需要导入模块: from weibopy.auth import OAuthHandler [as 别名]
# 或者: from weibopy.auth.OAuthHandler import get_access_token [as 别名]
class Test(unittest.TestCase):
    
    consumer_key=''
    consumer_secret=''
    
    def __init__(self):
            """ constructor """
    
    def getAtt(self, key):
        try:
            return self.obj.__getattribute__(key)
        except Exception as e:
            print(e)
            return ''
        
    def auth(self):
        
        if len(self.consumer_key) == 0:
            print("Please set consumer_key£¡£¡£¡")
            return
        
        if len(self.consumer_key) == 0:
            print("Please set consumer_secret£¡£¡£¡")
            return
                
        self.auth = OAuthHandler(self.consumer_key, self.consumer_secret)
        auth_url = self.auth.get_authorization_url()
        print('Please authorize: ' + auth_url)
        verifier = input('PIN: ').strip()
        self.auth.get_access_token(verifier)
        self.api = API(self.auth)
        
    def setAccessToken(self, key, secret):
        self.auth = OAuthHandler(self.consumer_key, self.consumer_secret)
        self.auth.setAccessToken(key, secret)
        self.api = API(self.auth)
    
    def update(self, message):
        status = self.api.update_status(message)
        self.obj = status
        id = self.getAtt("id")
        text = self.getAtt("text")
        print("update,id="+ str(id) +",text="+ text)
        
    def destroy_status(self, id):
        status = self.api.destroy_status(id)
        self.obj = status
        id = self.getAtt("id")
        text = self.getAtt("text")
        print("update---"+ str(id) +":"+ text)

# 需要导入模块: from weibopy.auth import OAuthHandler [as 别名]
# 或者: from weibopy.auth.OAuthHandler import get_access_token [as 别名]
def get_sina_token():      
    #申请应用时得到的App Key及密码  
    App_key = '3028524014'  
    App_secret = '660eb5d3feacc40d3bba28e0b9dcc50b'  
  
    #授权  
    auth_handler = OAuthHandler(App_key, App_secret)  
    auth_url = auth_handler.get_authorization_url()  
  
    print "Please open this url by your Browser:" + auth_url  
    verifier = raw_input('Please input PIN code get from above url: ').strip()  
      
    #得到token及密码  
    auth_handler.get_access_token(verifier)  

# 需要导入模块: from weibopy.auth import OAuthHandler [as 别名]
# 或者: from weibopy.auth.OAuthHandler import get_access_token [as 别名]
 def sinaapp(self,app_key,app_secret):
         auth = OAuthHandler(app_key, app_secret)  ##认证
         auth_url = auth.get_authorization_url()    ##返回授权页面链接，用浏览器打开
         #webbrowser.open(auth_url)
         content = self._request(auth_url)[1].read()        
         soup=BeautifulSoup.BeautifulSoup(''.join(content))
         #print content
         pin=soup.span.string   #自动获取pin码
         #print 'Please authorize: ' + auth_url  ##输入获得的Pin码
         #verifier = raw_input('输入您在浏览器页面显示的PIN码: ').strip()
         auth.get_access_token(pin)
         api = API(auth)  #整合函数
         connent=raw_input('What are you want to say?')
         status = api.update_status(status=connent)#发布微博
         print "Send Successed"
         raw_input('Press enter to exit ......')

# 需要导入模块: from weibopy.auth import OAuthHandler [as 别名]
# 或者: from weibopy.auth.OAuthHandler import get_access_token [as 别名]
    def get(self):
        invitationCode = self.request.get('invitation_code')
        if not self.isValidInvitationCode(invitationCode):
            error_output(self, "<html><body>邀请码无效</body></html>", "text/html", 400)
            return
        auth = OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
        
        verifier = self.request.get("oauth_verifier").strip()
        twitterId = self.request.get("twitter_id").strip()
        if verifier == "" or twitterId == "":
            authUrl = auth.get_authorization_url()
            success_output(self, page_goto_sina_oauth % \
                {'url':authUrl, 
                 'invitation':invitationCode.encode('UTF-8'),
                 'token':auth.request_token.key, 
                 'secret':auth.request_token.secret})
        else:
            request_token = self.request.get("request_token")
            request_secret = self.request.get("request_secret")
            auth.set_request_token(request_token, request_secret)
            accessToken = auth.get_access_token(verifier)
            binding = SyncBinding.getOrInsertByInvitationCode(invitationCode)
            binding.lastTweetId = None
            binding.twitterId = twitterId
            binding.sinaAccessToken = accessToken.key
            binding.sinaAccessSecret = accessToken.secret
            binding.put()
            success_output(self, '''
<html><body>
<p>Twitter与新浪微博同步绑定成功</p>
<p>如需要修改绑定，请重新访问邀请链接</p>
</body></html>
            ''')

# 需要导入模块: from weibopy.auth import OAuthHandler [as 别名]
# 或者: from weibopy.auth.OAuthHandler import get_access_token [as 别名]
 def init_2nd_step(self, verifier_num):
     info = user.get_app('sina', self.email)
     auth = OAuthHandler(APP_KEY, APP_SECRET)
     auth.set_request_token(info.get('request_token'), info.get('request_secret'))
     access = auth.get_access_token(verifier_num)
     user.update_app('sina', self.email, access_token=access.key, access_secret=access.secret)
     return True

# 需要导入模块: from weibopy.auth import OAuthHandler [as 别名]
# 或者: from weibopy.auth.OAuthHandler import get_access_token [as 别名]
 def GET(self):
     oauth_token = web.input().oauth_token
     oauth_verifier = web.input().oauth_verifier
     auth = OAuthHandler(oauth.APP_KEY, oauth.APP_SECRET)
     auth.set_request_token(session.rtKey[web.ctx.ip], session.rtSec[web.ctx.ip])
     access_token = auth.get_access_token(oauth_verifier)
     session.atKey[web.ctx.ip] = access_token.key
     session.atSec[web.ctx.ip] = access_token.secret
     raise web.seeother('/sinaweibo/timeline')

# 需要导入模块: from weibopy.auth import OAuthHandler [as 别名]
# 或者: from weibopy.auth.OAuthHandler import get_access_token [as 别名]
def login(request):
    '''get a permanent access token'''
    session = get_current_session()
    if not request.GET.get('oauth_token'):
        '''login and save oauth token'''
        cur_url = _get_absolute_path(request)
        auth = OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET, callback = cur_url)
        auth_url = auth.get_authorization_url()
        # 需要保存request_token的信息，留做取access_token用
        session["oauth_token"] = auth.request_token.key
        session["oauth_token_secret"] = auth.request_token.secret
        return http.HttpResponseRedirect(auth_url)
    else:
        ''' Get the access token '''
        oauth_verifier = request.GET.get('oauth_verifier')
        auth = OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
        # 从session中取出request_token的信息
        auth.set_request_token(session["oauth_token"], session["oauth_token_secret"])
        auth.get_access_token(oauth_verifier)
        # save access token
        session['access_token_key'] = auth.access_token.key
        session['access_token_secret'] = auth.access_token.secret
        response = shortcuts.redirect('sinaweibo.views.mainPage')
        return response
        
        
    if 0:
        path = os.path.join(os.path.dirname(__file__), "templates/index.html")
        myself = api.get_user(id=1894001933)
        screen_name = myself. __getattribute__("screen_name")
        self.response.out.write(template.render(path,
                {"name": screen_name}))#dir(api.verify_credentials)}))#api.verify_credentials.name}))#screen_name}))

    if 0:
        params = {}
        params['test'] = 'nothing'
        return shortcuts.render_to_response('test.html', params)

    if 0:
        # add GET para and redirect
        response = shortcuts.redirect('sinaweibo.views.mainPage')
        response['Location'] += '?oauth_verifier=%s' % oauth_verifier
        return response
            

# 需要导入模块: from weibopy.auth import OAuthHandler [as 别名]
# 或者: from weibopy.auth.OAuthHandler import get_access_token [as 别名]
    def GET(sefl):
        ins=web.input()
        oauth_verifier=ins.get('oauth_verifier',None)
        request_token=session.get('request_token',None)
        auth=OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
        auth.request_token=request_token

        access_token=auth.get_access_token(oauth_verifier)
        session.access_token=access_token
        web.seeother("/")

# 需要导入模块: from weibopy.auth import OAuthHandler [as 别名]
# 或者: from weibopy.auth.OAuthHandler import get_access_token [as 别名]
def get_access_token(username, password):
    auth = OAuthHandler(APP_KEY, APP_SECRET)
    auth_url = auth.get_authorization_url()
    print "Auth URL: ",auth_url
    veri_obj = GetPIN(auth_url, username, password)   
    verifier = veri_obj.getPIN()
    print "VERIFIER: ",verifier
    if verifier==-1:
        raise Exception("Error Account")
    token = auth.get_access_token(verifier)
    return dict(parse_qsl(str(token)))

# 需要导入模块: from weibopy.auth import OAuthHandler [as 别名]
# 或者: from weibopy.auth.OAuthHandler import get_access_token [as 别名]
def login_callback():
    # This is called by the provider when user has granted permission to your app
    verifier = request.args.get('oauth_verifier', None)
    auth = OAuthHandler(APP_KEY, APP_SECRET)
    request_token = session['oauth_request_token']
    del session['oauth_request_token']
    
    # Show the provider it's us really
    auth.set_request_token(request_token.key, request_token.secret)
    # Ask for a temporary access token
    session['oauth_access_token'] = auth.get_access_token(verifier)
    return render_template("login_callback.html")

# 需要导入模块: from weibopy.auth import OAuthHandler [as 别名]
# 或者: from weibopy.auth.OAuthHandler import get_access_token [as 别名]
 def GET(self):
     try:
         ins=web.input()
         oauth_verifier=ins.get('oauth_verifier',None)
         request_token=session.get('request_token',None)
         auth=OAuthHandler(key.CONSUME_KEY, key.CONSUME_SECRET)
         auth.request_token=request_token
         #通过oauth_verifier来获取access_token
         access_token=auth.get_access_token(oauth_verifier)
         session.access_token=access_token
         web.seeother("/")
     except Exception:
         web.header("Content-Type", "text/html;charset=utf-8")
         return ':-( 出错了'

# 需要导入模块: from weibopy.auth import OAuthHandler [as 别名]
# 或者: from weibopy.auth.OAuthHandler import get_access_token [as 别名]
def do_auth():
    auth = OAuthHandler(APP_KEY, APP_SECRET, BACK_URL)
    auth_url = auth.get_authorization_url()
    request_token_key = auth.request_token.key
    request_token_secret = auth.request_token.secret
    auth.set_request_token(request_token_key, request_token_secret)
    webbrowser.open(auth_url)
    verifier = input("Verifier: ").strip()
    access_token = auth.get_access_token(verifier)
    ATK = access_token.key
    ATS = access_token.secret
    auth.setAccessToken(ATK, ATS)
    api = API(auth)
    user = api.verify_credentials()
    logging("[AUTH]: We are uing API from account: [uid = %s, name = %s]" % (user.id, user.screen_name))
    return api

# 需要导入模块: from weibopy.auth import OAuthHandler [as 别名]
# 或者: from weibopy.auth.OAuthHandler import get_access_token [as 别名]
 def get(self):
     print '123123123'
     verifier = self.get_argument('oauth_verifier', None)
     auth = OAuthHandler(SINA_CONSUME_KEY, SINA_CONSUME_SECRET)
     if not verifier:
         #self.SESSION['goto'] = self.get_argument('to_url', None)
         auth_url = auth.get_authorization_url()+'&oauth_callback='+self.request.protocol+'://'+self.request.host+'/people/auth/'
         self.SESSION['oauth_request_token'] = auth.request_token
         self.redirect(auth_url)
     else:
         request_token = self.SESSION['oauth_request_token']
         del self.SESSION['oauth_request_token']
         auth.set_request_token(request_token.key, request_token.secret)
         access_token = auth.get_access_token(verifier)
         self.SESSION['oauth_access_token'] = access_token
         me = WeiboAPI(auth).me()
         self.after_auth(me)

# 需要导入模块: from weibopy.auth import OAuthHandler [as 别名]
# 或者: from weibopy.auth.OAuthHandler import get_access_token [as 别名]
    def post(self):
        t_name = self.request.get('t_name')
        s_name = self.request.get('s_name')
        s_request_key = self.request.get('s_request_key')
        s_request_secret = self.request.get('s_request_secret')
        t_request_key = self.request.get('t_request_key')
        t_request_secret = self.request.get('t_request_secret')
        t_pin = self.request.get('t_pin')
        s_pin = self.request.get('s_pin')
        self.response.out.write("""<html><head><title>Tui2Lang-Result</title></head><body><center>""")
        if t_name == "" or s_name =="" or s_pin == "":
            self.response.out.write("""<h2>4 Input can not be empty! <a href="/">Back</a></h2>""")
        else:
            sina = OAuthHandler(app_key,app_secret)
            sina.set_request_token(s_request_key,s_request_secret)
            s_access_token = sina.get_access_token(s_pin.strip())
            sina_api = API(sina)

            twitter = tweepy.OAuthHandler(consumer_key,consumer_secret)
            twitter.set_request_token(t_request_key,t_request_secret)
            t_access_token = twitter.get_access_token(t_pin.strip())
            twitter_api = tweepy.API(twitter);
            
            t_tl = twitter_api.user_timeline()
            t_last_id = t_tl[0].id_str
            t_last_text = replace_tweet(t_tl[0].text)
            

            oauth_user = OauthUser(key_name=s_name)
            oauth_user.twitter_name = t_name
            oauth_user.sina_name = s_name
            oauth_user.sina_access_key = s_access_token.key
            oauth_user.sina_access_secret = s_access_token.secret
            oauth_user.twitter_access_key = t_access_token.key
            oauth_user.twitter_access_secret = t_access_token.secret
            oauth_user.twitter_last_id = t_last_id
            oauth_user.put()

            try:
                sina_api.update_status(t_last_text)            
            except WeibopError,e:
                self.response.out.write(e)
            else: