Python OAuthApi.getAccessToken方法代碼示例

# 需要導入模塊: from oauthtwitter import OAuthApi [as 別名]
# 或者: from oauthtwitter.OAuthApi import getAccessToken [as 別名]
def callback(request):
    req_token = oauth.Token.from_string(request.session.get('request_token'))
    api = OAuthApi(settings.CONSUMER_KEY, settings.CONSUMER_SECRET, req_token.key, req_token.secret)
    access_token = api.getAccessToken() 
    request.session["access_token"] = access_token.to_string()
    del request.session["request_token"]
    return HttpResponseRedirect(get_root_path() + "/")

# 需要導入模塊: from oauthtwitter import OAuthApi [as 別名]
# 或者: from oauthtwitter.OAuthApi import getAccessToken [as 別名]
def _do_finish(request):
    # TODO: refactor this out -- should be in a util class or on the model
    # TODO: add check for this, redirect if not found
    try:
        request_token = request.session['twitter_request_token']
        oauth = OAuthApi(settings.TWITTER['CONSUMER_KEY'], settings.TWITTER['CONSUMER_SECRET'], request_token)
        access_token = oauth.getAccessToken()

        twitter = OAuthApi(settings.TWITTER['CONSUMER_KEY'], settings.TWITTER['CONSUMER_SECRET'], access_token)
        user_info = twitter.GetUserInfo()

        default_account = AuthorizedAccount.objects.default_account()

        s = Seeder(
            twitter_id = user_info.id,
            twitter_username = user_info.screen_name,
            authorized_for = default_account
        )
        s.set_expires_on_in_days(request.session['duration'])
        s.save()

        Token.objects.create(
            seeder = s,
            oauth_token = access_token.key,
            oauth_token_secret = access_token.secret
        )
    except HTTPError:
        pass

# 需要導入模塊: from oauthtwitter import OAuthApi [as 別名]
# 或者: from oauthtwitter.OAuthApi import getAccessToken [as 別名]
    def get_profile_from_callback(self, request):
        """Extract the access token and profile details from OAuth callback"""
        request_token = request.session.get('twitter_request_token', None)
        if not request_token: return None

        token = oauth.OAuthToken.from_string(request_token)
        if token.key != request.GET.get('oauth_token', 'no-token'):
            return HttpResponse(status=400)

        twitter = OAuthApi(self.consumer_key, self.consumer_secret, token)
        access_token = twitter.getAccessToken()

        twitter = oauthtwitter.OAuthApi(self.consumer_key, 
                self.consumer_secret, access_token)
        try:
            profile = twitter.GetUserInfo()
        except:
            return None

        return {
            'access_token': access_token.to_string(),
            'id': profile.id,
            'username': profile.screen_name,
            'fullname': profile.name,
            'email': '',
        }

# 需要導入模塊: from oauthtwitter import OAuthApi [as 別名]
# 或者: from oauthtwitter.OAuthApi import getAccessToken [as 別名]
def oauth_return(request):
    if 'request_token' not in request.session:
        return redirect('dash.views.oauth_login')

    req_token = oauth.OAuthToken.from_string(request.session['request_token'])
    if req_token.key != request.GET.get('oauth_token', 'no-token'):
        del request.session['request_token']
        return redirect('dash.views.oauth_login')

    twitter = OAuthApi(CONSUMER_KEY, CONSUMER_SECRET, req_token)
    acc_token = twitter.getAccessToken()

    request.session['access_token'] = acc_token.to_string()
    auth_user = authenticate(access_token=acc_token)

    if auth_user:
        login(request, auth_user)
    else:
        del request.session['access_token']
        del request.session['request_token']
        return HttpResponse("Unable to authenticate you!")

    print "User: %s" % auth_user
    print "request.user: %s" % request.user
    print "is_auth: %s" % request.user.is_authenticated()
    return redirect('dash.views.home')

# 需要導入模塊: from oauthtwitter import OAuthApi [as 別名]
# 或者: from oauthtwitter.OAuthApi import getAccessToken [as 別名]
def get_access_token(window):
    auth_api = OAuthApi(CONSUMER_KEY, CONSUMER_SECRET)
    request_token = auth_api.getRequestToken()
    authorization_url = auth_api.getAuthorizationURL(request_token)

    webbrowser.open(authorization_url)
    auth_api = OAuthApi(CONSUMER_KEY, CONSUMER_SECRET, request_token)

    dialog = gtk.Dialog("Enter PIN", window, gtk.DIALOG_MODAL, (gtk.STOCK_OK, gtk.RESPONSE_OK, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL))
    entry = gtk.Entry()
    dialog.vbox.pack_start(entry)
    entry.show()
    response = dialog.run()
    dialog.hide()
    
    if response == gtk.RESPONSE_OK:
        pin = entry.get_text()

        try:
            access_token = auth_api.getAccessToken(pin)
        except HTTPError:
            access_token = None

        return access_token

    else:
        return None

# 需要導入模塊: from oauthtwitter import OAuthApi [as 別名]
# 或者: from oauthtwitter.OAuthApi import getAccessToken [as 別名]
def Callback(request):
    """docstring for Callback"""
    verifier=request.GET.get('oauth_verifier',None)
    request_token=request.session['request_token']
    twitter=OAuthApi(CONSUMER_KEY,CONSUMER_SECRET,request_token)
    # twitter=OAuthApi(CONSUMER_KEY,CONSUMER_SECRET)
    # access_token=twitter.getAccessToken(request_token,verifier)
    access_token=twitter.getAccessToken()
    # api=t.Api(CONSUMER_KEY,CONSUMER_SECRET,access_token['oauth_token'],access_token['oauth_token_secret'])
    twitter=OAuthApi(CONSUMER_KEY,CONSUMER_SECRET,access_token)
    # user=api.GetUserInfo()
    user=twitter.GetUserInfo()
    twitter_auth=UserMeta(user=request.user,key="oauth",value=1)
    twitter_auth.save()
    # twitter_access_token_key=UserMeta(user=request.user,key="access_token_key",value=access_token['oauth_token'])
    # twitter_access_token_key.save()
    # twitter_access_token_secret=UserMeta(user=request.user,key="access_token_secret",value=access_token['oauth_token_secret'])
    # twitter_access_token_secret.save()
    twitter_access_token_string=UserMeta(user=request.user,key="twitter_access_token_string",value=access_token.to_string())
    twitter_access_token_string.save()
    twitter_id=UserMeta(user=request.user,key="twitter_id",value=user.id)
    twitter_id.save()
    twitter_name=UserMeta(user=request.user,key="twitter_name",value=user.name)
    twitter_name.save()
    twitter_screen_name=UserMeta(user=request.user,key="twitter_screen_name",value=user.screen_name)
    twitter_screen_name.save()
    twitter_description=UserMeta(user=request.user,key="twitter_description",value=user.description)
    twitter_description.save()
    twitter_profile_image_url=UserMeta(user=request.user,key="twitter_profile_image_url",value=user.profile_image_url)
    twitter_profile_image_url.save()
    return HttpResponseRedirect("/setting")

# 需要導入模塊: from oauthtwitter import OAuthApi [as 別名]
# 或者: from oauthtwitter.OAuthApi import getAccessToken [as 別名]
	def finalize_handshake( self, request ):
		twitter = OAuthApi( TWITTER_KEY, TWITTER_SECRET, request.session[ 'request_token' ] )
		request.session[ 'access_token' ] = twitter.getAccessToken()
		twitter = OAuthApi( TWITTER_KEY, TWITTER_SECRET, request.session[ 'access_token' ] )
		user_info = twitter.GetUserInfo()
		request.session[ 'twitter_info' ] = user_info
		return request		

# 需要導入模塊: from oauthtwitter import OAuthApi [as 別名]
# 或者: from oauthtwitter.OAuthApi import getAccessToken [as 別名]
    def generate(self):
        # get the bitly information
        self.getValueFromUser('BITLY_USER', "bit.ly username: ")
        self.getValueFromUser('BITLY_KEY',
                              "api key from 'http://bit.ly/a/account': ")

        # get the twitter information
        from oauthtwitter import OAuthApi
        twitter = OAuthApi(self.__APP_KEY, self.__APP_SECRET)
        temp_creds = twitter.getRequestToken()
        print "visit '%s' and write the pin:" \
            % twitter.getAuthorizationURL(temp_creds)
        oauth_verifier = sys.stdin.readline().strip()
        access_token = twitter.getAccessToken(temp_creds, oauth_verifier)
        config['TWIT_TOKEN'] = access_token['oauth_token']
        config['TWIT_SECRET'] = access_token['oauth_token_secret']

        # get the svn information
        self.getValueFromUser('SVN_FS_ROOT', "Root directory for svn: ",
                              '/svn/')
        self.getValueFromUser('SVN_TRAC_FORMAT',
                              "Format for trac svn urls: ",
                              "http://trac.edgewall.org/changeset/%d")

        # write out the configuration
        handle = open(filename, 'w')
        keys = self.__config__.keys()
        keys.sort()
        for key in keys:
            handle.write("%s='%s'\n" % (key, config[key]))
        handle.write("def normalizeUser(user):\n")
        handle.write("    return user\n")
        pphandle.close()

# 需要導入模塊: from oauthtwitter import OAuthApi [as 別名]
# 或者: from oauthtwitter.OAuthApi import getAccessToken [as 別名]
    def get(self):
        # get req token from DB
        token = self.request.get("oauth_token")
        req_token = fetcher.get_req_token_by_oauth_token(token)
        if not req_token:
            self.redirect('/oauth/twitter/signin')
            return
        
        # model to object
        req_token_obj = oauth.OAuthToken(req_token.token, req_token.secret)
        return_url = req_token.return_url
        
        # get access token
        twit = OAuthApi(access_token=req_token_obj)
        try:
            access_token = twit.getAccessToken()
        except DownloadError:
            self.redirect_error(msg="twitter is over capacity")
            return
            
        token = access_token.key
        secret = access_token.secret
        # delete OAuthToken
        fetcher.delete_req_token_by_model(req_token)
        
        # get user info 
        try:
            twit = OAuthApi(access_token=access_token)
            user = twit.GetUserInfo()
        except DownloadError:
            self.redirect_error(msg="twitter is over capacity")
            return
        

        # add user 
        user_model = fetcher.set_user(twit_id=str(user.id),
                                      twit_name=user.name,
                                      twit_screen_name=user.screen_name,
                                      twit_img_url=user.profile_image_url)
        
        
        # add session
        self.new_session(user_model, token, secret)        
        
        # redirect to home
        if not return_url:
            return_url = '/' 
        self.redirect(return_url)

# 需要導入模塊: from oauthtwitter import OAuthApi [as 別名]
# 或者: from oauthtwitter.OAuthApi import getAccessToken [as 別名]
def get_user_tokens(app_key, app_secret_key):
    if not os.path.isfile("../terminitter.oauth"):  # no user tokens found, create some
        twitter = OAuthApi(app_key, app_secret_key)
        temp_credentials = twitter.getRequestToken()

        print(twitter.getAuthorizationURL(temp_credentials))
        oauth_verifier = raw_input("Go the the URL above, and paste the PIN here: ")
        tokens = twitter.getAccessToken(temp_credentials, oauth_verifier)

        oauthf = open("../terminitter.oauth", "w")
        oauthf.write(tokens["oauth_token"] + "\n" + tokens["oauth_token_secret"])
        oauthf.close()
        return [access_token["oauth_token"], access_token["oauth_token_secret"]]
    else:  # read user tokens from file
        oauthf = open("../terminitter.oauth", "r")
        oauth_tokens = oauthf.read().splitlines()
        return [oauth_tokens[0], oauth_tokens[1]]

# 需要導入模塊: from oauthtwitter import OAuthApi [as 別名]
# 或者: from oauthtwitter.OAuthApi import getAccessToken [as 別名]
def twitter_return(request):
    request_token = request.session.get('request_token', None)

    # If there is no request_token for session,
    #    means we didn't redirect user to twitter
    if not request_token:
        # Redirect the user to the login page,
        # So the user can click on the sign-in with twitter button
        return HttpResponse("We didn't redirect you to twitter...")

    token = oauth.OAuthToken.from_string(request_token)

    # If the token from session and token from twitter does not match
    #   means something bad happened to tokens
    if token.key != request.GET.get('oauth_token', 'no-token'):
        del request.session['request_token']
        # Redirect the user to the login page
        return HttpResponse("Something wrong! Tokens do not match...")

    twitter = OAuthApi(CONSUMER_KEY, CONSUMER_SECRET, token)
    try:
        fr = twitter.GetFriendsTimeline()
    except HTTPError as e:
        return HttpResponse(str(e))
    access_token = twitter.getAccessToken()
    request.session['access_token'] = access_token.to_string()
    auth_user = authenticate(access_token=access_token)

    # if user is authenticated then login user
    if auth_user:
        login(request, auth_user)
    else:
        # We were not able to authenticate user
        # Redirect to login page
        del request.session['access_token']
        del request.session['request_token']
        return HttpResponse("Unable to authenticate you!")
    # authentication was successful, use is now logged in
#    foo = twitter.GetFollowers()
#    return HttpResponse("You are logged in %s" % twitter.GetFriends())
#    return HttpResponse("You are logged in" + len(foo))
    import string
    return HttpResponse("You are logged in %s" % twitter.GetPublicTimeline())

# 需要導入模塊: from oauthtwitter import OAuthApi [as 別名]
# 或者: from oauthtwitter.OAuthApi import getAccessToken [as 別名]
class OauthAccess():
  
    CONSUMER_KEY = settings.TWITTER_CONSUMER_KEY  
    CONSUMER_SECRET = settings.TWITTER_CONSUMER_SECRET  
    ACCESS_TOKEN_URL = settings.TWITTER_ACCESS_TOKEN_URL
  
    mPin = ""
    mOauthRequestToken = ""
    mOauthAccessToken = ""
    mUser = twitter.User
    mTwitterApi = ""
  
    def __init__(self, pOauthRequestToken, pPin):
        self.mOauthRequestToken = pOauthRequestToken
        self.mPin = pPin
  
    def getOauthAccess(self):
        self.mTwitterApi = OAuthApi(self.CONSUMER_KEY, self.CONSUMER_SECRET, self.mOauthRequestToken)
        self.mOauthAccessToken = self.mTwitterApi.getAccessToken(self.mPin)
        self.mAuthenticatedTwitterInstance = OAuthApi(self.CONSUMER_KEY, self.CONSUMER_SECRET, self.mOauthAccessToken)
        self.mUser = self.mAuthenticatedTwitterInstance.GetUserInfo()

# 需要導入模塊: from oauthtwitter import OAuthApi [as 別名]
# 或者: from oauthtwitter.OAuthApi import getAccessToken [as 別名]
class OauthAccess():  
  
    CONSUMER_KEY = "UsGVAZvCxNiZsO7eKkSZzA"  
    CONSUMER_SECRET = "M3lOLh3w9tsgEPG423EhPSkHobGHfinXR2Ju4lxkc"  
    ACCESS_TOKEN_URL = 'https://twitter.com/oauth/access_token'  
  
    mPin = ""  
    mOauthRequestToken = ""  
    mOauthAccessToken = ""  
    mUser = twitter.User  
    mTwitterApi = ""  
  
    def __init__(self, pOauthRequestToken, pPin):  
        self.mOauthRequestToken = pOauthRequestToken  
        self.mPin = pPin  
  
    def getOauthAccess(self):  
        self.mTwitterApi = OAuthApi(self.CONSUMER_KEY, self.CONSUMER_SECRET, self.mOauthRequestToken)  
        self.mOauthAccessToken = self.mTwitterApi.getAccessToken(self.mPin)  
        self.mAuthenticatedTwitterInstance = OAuthApi(self.CONSUMER_KEY, self.CONSUMER_SECRET, self.mOauthAccessToken)  
        self.mUser = self.mAuthenticatedTwitterInstance.GetUserInfo() 

# 需要導入模塊: from oauthtwitter import OAuthApi [as 別名]
# 或者: from oauthtwitter.OAuthApi import getAccessToken [as 別名]
class OauthAccess():
 
    CONSUMER_KEY = "atG3B3lZ6fOKshfiUr5FAMDER"
    CONSUMER_SECRET = "zJ52dNaHe3CHDHZahmBC7JwciUS93rFhf5pPzk79CqKZN37R1z"
    ACCESS_TOKEN_URL = 'https://twitter.com/oauth/access_token'
 
    mPin = ""
    mOauthRequestToken = ""
    mOauthAccessToken = ""
    mUser = twitter.User
    mTwitterApi = ""
 
    def __init__(self, pOauthRequestToken, pPin):
        self.mOauthRequestToken = pOauthRequestToken
        self.mPin = pPin
 
    def getOauthAccess(self):
        self.mTwitterApi = OAuthApi(self.CONSUMER_KEY, self.CONSUMER_SECRET, self.mOauthRequestToken)
        self.mOauthAccessToken = self.mTwitterApi.getAccessToken(self.mPin)
        self.mAuthenticatedTwitterInstance = OAuthApi(self.CONSUMER_KEY, self.CONSUMER_SECRET, self.mOauthAccessToken)
        self.mUser = self.mAuthenticatedTwitterInstance.GetUserInfo()

# 需要導入模塊: from oauthtwitter import OAuthApi [as 別名]
# 或者: from oauthtwitter.OAuthApi import getAccessToken [as 別名]
    def setup(self):
        os.system('clear')

        twitter = OAuthApi(self.consumer_key, self.consumer_secret)

        # Get the temporary credentials for our next few calls
        temp_credentials = twitter.getRequestToken()

        # User pastes this into their browser to bring back a pin number
        print(twitter.getAuthorizationURL(temp_credentials))

        # Get the pin # from the user and get our permanent credentials
        oauth_verifier = raw_input('What is the PIN? ')
        access_token = twitter.getAccessToken(temp_credentials, oauth_verifier)

        self.token = access_token['oauth_token']
        self.secret = access_token['oauth_token_secret']

        self.latest = 1
        self.mention = 1

        print 'Clitwi was successfully set up.'