Python OAuthToken.from_string方法代码示例

# 需要导入模块: from oauth import OAuthToken [as 别名]
# 或者: from oauth.OAuthToken import from_string [as 别名]
 def exchange_request_token_for_access_token(self, request_token, verifier):
     parameters = {"oauth_verifier": verifier}
     oauth_request = self.build_oauth_request(
         self.get_access_token_url(), request_token, parameters=parameters
     )
     response = self.execute(oauth_request)
     return OAuthToken.from_string(response)

# 需要导入模块: from oauth import OAuthToken [as 别名]
# 或者: from oauth.OAuthToken import from_string [as 别名]
 def get_access_token(self, request_token):
     url = API_HOME + '/oauth/access_token'
     client = OAuthClient(self.consumer, token=request_token)
     resp, content = client.request(url)
     if resp['status'] != '200':
         raise Exception("Invalid response %s." % resp['status'])
     return OAuthToken.from_string(content)

# 需要导入模块: from oauth import OAuthToken [as 别名]
# 或者: from oauth.OAuthToken import from_string [as 别名]
def execute_khan_api_method(profile_access_token, api_method, cache_timeout=(60 * 60 * 2), 
                            force_refresh=False, return_raw_text=False, user_id=None, 
                            disk_cache=True, cache_per_user=True):
    
    cache_key = ""
    _chosen_cache = get_cache('default')
    if disk_cache:
        _chosen_cache = get_cache('disk')
    
    if cache_per_user:
        if user_id is not None:
            cache_key = "%s^%s^%s" % (user_id, api_method, return_raw_text)
        else:
            cache_key = "%s^%s^%s" % (profile_access_token, api_method, return_raw_text)
    else:
        cache_key = "%s^%s" % (api_method, return_raw_text)
    
    cache_key = cache_key.replace("/","^")
    cache_key = cache_key.replace(".","^")
    cache_key = cache_key.replace(":","^")
    cache_key = cache_key.replace(" ","^")
    
    cache_hit = False
    result_data = _chosen_cache.get(cache_key)
    
    if force_refresh or result_data is None:
        resource = CLIENT.access_api_resource(
            api_method,
            access_token = OAuthToken.from_string(profile_access_token),
            method = "GET"
            )
        
        text = resource['body']
        
        # Error messages can contain HTML. Escape them so they're not rendered.
        is_html = has_text_html_header(resource['headers'])
        if is_html:
            text = cgi.escape(text)
        
        print text
        
        try:
            if return_raw_text:
                result_data = text
            else:
                result_data = simplejson.loads(text)
                
            _chosen_cache.set(cache_key, result_data, cache_timeout)
        except:
            print "exception storing in cache"
        
    else:
        # print "Got json data from cache!"
        cache_hit = True
    
    if not cache_hit:
        # update local tables with fresh data
        print "(cache not hit or is empty: Update local tables with data)"
    
    return result_data

# 需要导入模块: from oauth import OAuthToken [as 别名]
# 或者: from oauth.OAuthToken import from_string [as 别名]
def fireeagle( request ):
    if request.user.fireeagle_token:
        if 'next' in request.session:
            next = request.session['next']
            del request.session['next']
        else:
            next = "/"
        return HttpResponseRedirect( next )

    if not 'oauth_token' in request.GET:
        apptoken = fe.request_token()
        request.session['apptoken'] = apptoken.to_string()
        auth_url = fe.authorize( apptoken )
        if request.session['mobile']:
            auth_url = re.sub(r'https://fireeagle.yahoo.net/', "https://m.fireeagle.yahoo.net/", auth_url)
        logging.info("Redirecting to %s for auth"%auth_url)
        return HttpResponseRedirect( auth_url )

    else:
        apptoken = OAuthToken.from_string( request.session['apptoken'] )
        user_token = fe.access_token( apptoken )
        request.user.fireeagle_token = user_token.to_string()
        request.user.location_from_fireeagle( fe )
        request.user.save()
        if 'next' in request.session:
            next = request.session['next']
            del request.session['next']
        else:
            next = "/"
        return HttpResponseRedirect( next )

# 需要导入模块: from oauth import OAuthToken [as 别名]
# 或者: from oauth.OAuthToken import from_string [as 别名]
 def exchange_request_token_for_access_token(self, token):
     oauth_request = OAuthRequest.from_consumer_and_token(self.consumer,
             token=token, http_url=URL_OAUTH_ACCESS_TOKEN)
     oauth_request.sign_request(self.signature_method, self.consumer,
             token)
     resp = self.oauth_fetch(oauth_request, raw=True)
     self.access_token = OAuthToken.from_string(resp) 
     return self.access_token

# 需要导入模块: from oauth import OAuthToken [as 别名]
# 或者: from oauth.OAuthToken import from_string [as 别名]
 def get_request_token(self, callback=None):
     url = API_HOME + '/oauth/request_token'
     client = OAuthClient(self.consumer) 
     resp, content =  client.request(url, callback=callback,
                                     force_auth_header=False) 
     if resp['status'] != '200':
         raise Exception("Invalid response %s." % resp['status'])
     return OAuthToken.from_string(content)

# 需要导入模块: from oauth import OAuthToken [as 别名]
# 或者: from oauth.OAuthToken import from_string [as 别名]
 def fetch_request_token(self, oauth_request):
     # via headers
     # -> OAuthToken
     self.connection.request(oauth_request.http_method, self.request_token_url, headers=oauth_request.to_header())
     response = self.connection.getresponse()
     if response.status != 200:
         raise Exception("Error making request: " + str(response.read()))
     return OAuthToken.from_string(response.read())

# 需要导入模块: from oauth import OAuthToken [as 别名]
# 或者: from oauth.OAuthToken import from_string [as 别名]
 def is_authenticated(self, access_token):
     if not isinstance(access_token, OAuthToken):
         access_token = OAuthToken.from_string(access_token)
     oauth_request = self.build_oauth_request(self.check_auth_url, access_token)
     response = json.loads(self.execute(oauth_request))
     if "screen_name" in response:
         self.set_access_token(access_token)
         return response["screen_name"]
     return False

# 需要导入模块: from oauth import OAuthToken [as 别名]
# 或者: from oauth.OAuthToken import from_string [as 别名]
 def get_unauthorized_request_token(self, oauth_callback=None):
     parameters = {}
     if oauth_callback:
         parameters = {"oauth_callback": oauth_callback}
     oauth_request = self.build_oauth_request(
         self.get_request_token_url(), parameters = parameters
     )
     response = self.execute(oauth_request)
     return OAuthToken.from_string(response)

# 需要导入模块: from oauth import OAuthToken [as 别名]
# 或者: from oauth.OAuthToken import from_string [as 别名]
    def fetch_access_token(self, oauth_request):
        # via headers
        # -> OAuthToken
        self.connection.request(oauth_request.http_method, self.access_token_url, headers=oauth_request.to_header())
        response = self.connection.getresponse()
        if response.status != 200:
            logging.warn("Error temp cred -- response from server:\n" + response.read())
            raise Exception("Error: did not get a temp cred. Response code=" + str(response.status))

        return OAuthToken.from_string(response.read())

# 需要导入模块: from oauth import OAuthToken [as 别名]
# 或者: from oauth.OAuthToken import from_string [as 别名]
    def fetch_access_token(self, request_token):

        oauth_request = OAuthRequest.from_consumer_and_token(
            self.consumer, token=request_token, http_url="%s/api/auth/access_token" % self.server_url
        )

        oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(), self.consumer, request_token)

        response = get_response(oauth_request.to_url())

        return OAuthToken.from_string(response)

# 需要导入模块: from oauth import OAuthToken [as 别名]
# 或者: from oauth.OAuthToken import from_string [as 别名]
    def return_helper(self, request, **kwargs):
        from django.http import Http404

        if not "request_token" in request.session:
            raise Http404()
        token = OAuthToken.from_string(request.session["request_token"])
        del request.session["request_token"]
        if token.key != request.GET.get("oauth_token", "no-token"):
            raise Http404()
        verifier = request.GET["oauth_verifier"]
        access_token = self.exchange_request_token_for_access_token(token, verifier)
        request.session["access_token"] = access_token.to_string()

# 需要导入模块: from oauth import OAuthToken [as 别名]
# 或者: from oauth.OAuthToken import from_string [as 别名]
def access_token():
    try:
        token_string = session['oauth_token_string']
    except KeyError:
        token_string = None

    # Sanity check.
    if not token_string:
        clear_session()
        return None
        
    return OAuthToken.from_string(token_string)

# 需要导入模块: from oauth import OAuthToken [as 别名]
# 或者: from oauth.OAuthToken import from_string [as 别名]
    def auth(self, request_token, verifier):
        self.request_token = OAuthToken.from_string(request_token)
        request = OAuthRequest.from_consumer_and_token(
            self.consumer,
            token=self.request_token,
            http_url=self.access_token_url,
            verifier=str(verifier)
        )
        request.sign_request(
            OAuthSignatureMethod_HMAC_SHA1(),
            self.consumer,
            self.request_token
            )

        #if mode == 'header':
        #    resp = urllib2.urlopen(urllib2.Request(url, headers=request.to_header()))
        #else:
        #    resp = urllib2.urlopen(urllib2.Request(request.to_url()))
        resp = urllib2.urlopen(urllib2.Request(request.to_url()))
        string = resp.read()
        access_token = OAuthToken.from_string(string)
        self.access_token = access_token
        self._process_access_token(string)

# 需要导入模块: from oauth import OAuthToken [as 别名]
# 或者: from oauth.OAuthToken import from_string [as 别名]
def access_token(session):
    try:
        token_string = session['oauth_token_string']
    except KeyError:
        print 'Got key error'
        token_string = None

    # Sanity check.
    if not token_string:
        print 'Not token string'
        clear_session(session)
        return None
        
    oauth_token = OAuthToken.from_string(token_string)
    print 'Oauth token %s' % oauth_token
    return oauth_token