Python OAuthRequest.from_consumer_and_token方法代码示例

# 需要导入模块: from oauth.oauth import OAuthRequest [as 别名]
# 或者: from oauth.oauth.OAuthRequest import from_consumer_and_token [as 别名]
def auth(request, site):
	creds = OAUTH_CREDENTIALS.get(site.upper())
	if not creds:
		raise Http404('Site %s not found' % site)
	
	urls = creds.get('URLS', {})
	
	if 'DIALOG' in urls:
		request.session['preauth_url'] = request.META.get('HTTP_REFERER')
		return HttpResponseRedirect(urls['DIALOG'])
	
	ssl = creds.get('SSL', False)
	server = creds.get('SERVER', '%s.com' % site.lower())
	klass = ssl and HTTPSConnection or HTTPConnection
	
	request.session['preauth_url'] = request.META.get('HTTP_REFERER')
	
	consumer = OAuthConsumer(
		str(creds['CONSUMER_KEY']),
		str(creds['CONSUMER_SECRET'])
	)
	
	oauth_request = OAuthRequest.from_consumer_and_token(
		consumer, http_url = urls.get('REQUEST_TOKEN')
	)
	
	oauth_request.sign_request(SIGNATURE_METHOD(), consumer, None)
	url = oauth_request.to_url()
	
	connection = klass(server)
	connection.request(oauth_request.http_method, url)
	response = connection.getresponse()
	resp = response.read()
	
	token = OAuthToken.from_string(resp)
	request.session['unauth_token'] = token
	
	auth_url = urls.get('AUTHORISATION')
	if isinstance(auth_url, (list, tuple)):
		params = auth_url[1]
		auth_url = auth_url[0]
	else:
		params = {}
	
	oauth_request = OAuthRequest.from_consumer_and_token(
		consumer, token = token,
		http_url = auth_url, parameters = params
	)
	
	oauth_request.sign_request(SIGNATURE_METHOD(), consumer, token)
	return HttpResponseRedirect(
		oauth_request.to_url()
	)

# 需要导入模块: from oauth.oauth import OAuthRequest [as 别名]
# 或者: from oauth.oauth.OAuthRequest import from_consumer_and_token [as 别名]
def getTwitterOAuthURL(conf, oauthTokenDict):
    """
    Obtain a URL from twitter.com that we can redirect a user to so they
    can authenticate themselves and authorize loveme.do to act on their
    behalf.

    @param conf: the lovemedo configuration.
    @param oauthTokenDict: A C{dict} mapping token keys to tokens.
    @return: A C{Deferred} that fires with the URL for OAuth verification.
    """
    log.msg('Got login URL request.')

    def _makeURL(result):
        token = OAuthToken.from_string(result)
        # Store the token by key so we can find it when the callback comes.
        oauthTokenDict[token.key] = token
        request = OAuthRequest.from_token_and_callback(
            token=token, http_url=conf.authorization_url)
        url = request.to_url()
        log.msg('Browser OAuth redirect URL = %r' % url)
        return url

    consumer = OAuthConsumer(conf.consumer_key, conf.consumer_secret)
    request = OAuthRequest.from_consumer_and_token(
        consumer, callback=conf.callback_url,
        http_url=conf.request_token_url)
    request.sign_request(OAuthSignatureMethod_HMAC_SHA1(), consumer, None)
    r = RetryingCall(
        client.getPage, conf.request_token_url, headers=request.to_header())
    d = r.start()
    d.addCallback(_makeURL)
    d.addErrback(log.err)
    return d

# 需要导入模块: from oauth.oauth import OAuthRequest [as 别名]
# 或者: from oauth.oauth.OAuthRequest import from_consumer_and_token [as 别名]
    def fetch_access_token(self,
                           unauth_request_token_key,
                           unauth_request_token_secret,
                           oauth_verifier):
        """ After the user has authorizated API access via the authorization
        URL, get the (semi-)permanent access key using the user-authorized
        request token.

        Keyword arguments:
        unauth_request_token -- the user-authorized OAuth request token
        oauth_verifier -- per OAuth 1.0 Revision A

        """
        url = "%s?oauth_verifier=%s" % (YAMMER_ACCESS_TOKEN_URL,
                                        oauth_verifier)
        try:
            unauth_request_token = OAuthToken(unauth_request_token_key,
                                              unauth_request_token_secret)
            oauth_request = OAuthRequest.from_consumer_and_token(
                                                self._consumer,
                                                token=unauth_request_token,
                                                http_method='POST',
                                                http_url=url)
            oauth_request.sign_request(self._signature,
                                       self._consumer,
                                       unauth_request_token)
            headers = oauth_request.to_header()
        except OAuthError, m:
            raise YammerError(m.message)

# 需要导入模块: from oauth.oauth import OAuthRequest [as 别名]
# 或者: from oauth.oauth.OAuthRequest import from_consumer_and_token [as 别名]
    def _fetch_resource(self, url, parameters=None, method = 'GET'):
        """ Retrieve a Yammer API resource.

        Keyword arguments:
        url -- a Yammer API URL (excluding query parameters)
        parameters -- used to pass query parameters to add to the request
                      (optional).

        """
        if not self._access_token:
            raise YammerError("Can't fetch resource. Missing access token!")

        try:
            oauth_request = OAuthRequest.from_consumer_and_token(
                                                self._consumer,
                                                token=self._access_token,
                                                http_method=method,
                                                http_url=url,
                                                parameters=parameters)
            headers = oauth_request.to_header()
            oauth_request.sign_request(self._signature,
                                       self._consumer,
                                       self._access_token)
            url = oauth_request.to_url()
        except OAuthError, m:
            raise YammerError(m.message)

# 需要导入模块: from oauth.oauth import OAuthRequest [as 别名]
# 或者: from oauth.oauth.OAuthRequest import from_consumer_and_token [as 别名]
    def get_request(self, headers=None, **kwargs):
        request = super(Flixject, self).get_request(headers=headers, **kwargs)
        method = request.get('method', 'GET')

        # Apply OAuthness.
        csr = OAuthConsumer(*self.api_token)
        orq = OAuthRequest.from_consumer_and_token(csr, http_method=method,
            http_url=request['uri'])

        # OAuthRequest will strip our query parameters, so add them back in.
        parts = list(urlparse.urlparse(self._location))
        queryargs = cgi.parse_qs(parts[4], keep_blank_values=True)
        for key, value in queryargs.iteritems():
            orq.set_parameter(key, value[0])

        # Sign the request.
        osm = OAuthSignatureMethod_HMAC_SHA1()
        orq.set_parameter('oauth_signature_method', osm.get_name())
        orq.sign_request(osm, csr, None)

        if method == 'GET':
            request['uri'] = orq.to_url()
        else:
            request['headers'].update(orq.to_header())

        return request

# 需要导入模块: from oauth.oauth import OAuthRequest [as 别名]
# 或者: from oauth.oauth.OAuthRequest import from_consumer_and_token [as 别名]
	def fetch_url(self, url, token, **kwargs):
		from StringIO import StringIO
		
		token = OAuthToken.from_string(str(token))
		consumer = self.get_consumer()
		connection = self.get_connection(False)
		
		request = OAuthRequest.from_consumer_and_token(
			consumer, token = token, http_method = 'GET',
			http_url = url, parameters = kwargs
		)
		
		request.sign_request(self.signature_method, consumer, token)
		url = request.to_url()
		start = 'http://%s' % self.server
		
		if url.startswith(start):
			url = url[len(start):]
		
		start = 'https://%s' % self.server
		if url.startswith(start):
			url = url[len(start):]
		
		connection.request(request.http_method, url, '', request.to_header())
		resp = connection.getresponse().read()
		return StringIO(resp)

# 需要导入模块: from oauth.oauth import OAuthRequest [as 别名]
# 或者: from oauth.oauth.OAuthRequest import from_consumer_and_token [as 别名]
def exchange_request_token(request_token):
    consumer = OAuthConsumer(settings.ORCHARD_KEY, settings.ORCHAR_SECRET)
    oauth_request = OAuthRequest.from_consumer_and_token(
        consumer, request_token, http_url=ACCESS_TOKEN_URL)

    return OAuthToken.from_string(
        _make_request(consumer, oauth_request, request_token))

# 需要导入模块: from oauth.oauth import OAuthRequest [as 别名]
# 或者: from oauth.oauth.OAuthRequest import from_consumer_and_token [as 别名]
    def request(self, url, token=None, verb='GET', filename=None, **args):
        """`url` may be relative with regard to Netflix. Verb is a
        HTTP verb.

        """
        if isinstance(url, NetflixObject) and not isinstance(url, basestring):
            url = url.id
        if not url.startswith('http://'):
            url = self.protocol + self.host + url
        if 'output' not in args:
            args['output'] = 'json'
        args['method'] = verb.upper()

        postbody = None
        if verb.upper() == 'POST':
            args['method'] = 'GET'
            postbody = '&'.join(['%s=%s' % (escape(str(k)), escape(str(v))) \
                for k, v in args.iteritems()])
            args = {}

        # we don't want unicode in the parameters
        for k,v in args.iteritems():
            try:
                args[k] = v.encode('utf-8')
            except AttributeError:
                pass

        oa_req = OAuthRequest.from_consumer_and_token(self.consumer,
                                                      http_url=url,
                                                      parameters=args,
                                                      token=token)
        oa_req.sign_request(self.signature_method,
                            self.consumer,
                            token)
        if filename is None:
            def do_request():
                req = self.http.urlopen(verb, oa_req.to_url(), body=postbody)
                if not str(req.status).startswith('2'):
                    self.analyze_error(req)
                return req
        else:
            def do_request():
                try:
                    subprocess.check_call(["curl", oa_req.to_url(),
                                           "--location",
                                           "--compressed",
                                           "--output", filename])
                    sys.stderr.write('\nSaved to: %s\n' % filename)
                except OSError:
                    raise RuntimeError, "You need to have curl installed to use this command"
        try:
            req = do_request()
        except TooManyRequestsPerSecondError:
            time.sleep(1)
            req = do_request()
        if filename:
            return
        o = json.loads(req.data, object_hook=self.object_hook)
        return o

# 需要导入模块: from oauth.oauth import OAuthRequest [as 别名]
# 或者: from oauth.oauth.OAuthRequest import from_consumer_and_token [as 别名]
 def get_access_token(self, code):
     parameters = {}
     parameters['client_id'] = GITHUB_CLIENT_ID
     parameters['client_secret'] = GITHUB_CLIENT_SECRET
     parameters['code'] = code
     oauth_request = OAuthRequest.from_consumer_and_token(self.consumer, http_url=GITHUB_ACCESS_TOKEN_URL, parameters=parameters)
     access_token = get_response_from_url(oauth_request.to_url())       
     return access_token

# 需要导入模块: from oauth.oauth import OAuthRequest [as 别名]
# 或者: from oauth.oauth.OAuthRequest import from_consumer_and_token [as 别名]
    def begin(self, request, data):
        """
        Try to get Request Token from OAuth Provider and 
        redirect user to provider's site for approval.
        """
        consumer = OAuthConsumer(self.CONSUMER_KEY, self.CONSUMER_SECRET)
        signature_method = OAuthSignatureMethod_HMAC_SHA1()
        callback = request.build_absolute_uri(reverse('publicauth-complete', args=[self.provider]))
        oauth_req = OAuthRequest.from_consumer_and_token(consumer, callback=callback, http_url=self.REQUEST_TOKEN_URL)
        oauth_req.sign_request(signature_method, consumer, None)
        response = urllib.urlopen(oauth_req.to_url()).read()

        token = OAuthToken.from_string(response) # instatiate token

        oauth_req = OAuthRequest.from_consumer_and_token(consumer, token, http_url=self.AUTHORIZE_URL)
        oauth_req.sign_request(signature_method, consumer, token)
        raise Redirect(oauth_req.to_url())

# 需要导入模块: from oauth.oauth import OAuthRequest [as 别名]
# 或者: from oauth.oauth.OAuthRequest import from_consumer_and_token [as 别名]
    def make_requests_from_url(self, url):
        oauth_request = OAuthRequest.from_consumer_and_token(
                                            self.consumer,
                                            token=self.token,
                                            http_method='GET',
                                            http_url=url)
        oauth_request.sign_request(self.signature, self.consumer, self.token)

        return Request(oauth_request.to_url(), callback=self.parse, dont_filter=True)

# 需要导入模块: from oauth.oauth import OAuthRequest [as 别名]
# 或者: from oauth.oauth.OAuthRequest import from_consumer_and_token [as 别名]
	def get_authorisation_url(self, consumer = None, token = None):
		if self.token_required and (not consumer and not token):
			raise Exception('Consumer and token are required')
		
		oauth_request = OAuthRequest.from_consumer_and_token(
			consumer, token = token, http_url = self.authorise_url
		)
		
		oauth_request.sign_request(self.signature_method, consumer, token)
		return oauth_request.to_url()

# 需要导入模块: from oauth.oauth import OAuthRequest [as 别名]
# 或者: from oauth.oauth.OAuthRequest import from_consumer_and_token [as 别名]
 def get_request_token(self):
     oa_req = OAuthRequest.from_consumer_and_token(
         self.consumer,
         http_url=self.request_token_url)
     oa_req.sign_request(self.signature_method,
                               self.consumer,
                               None)
     req = self.http.get_url(self.request_token_url, headers = oa_req.to_header())
     if not str(req.status).startswith('2'):
         self.analyze_error(req)
     return OAuthToken.from_string(req.data)

# 需要导入模块: from oauth.oauth import OAuthRequest [as 别名]
# 或者: from oauth.oauth.OAuthRequest import from_consumer_and_token [as 别名]
    def oauth_request(self, token, url, extra_params=None):
        """Generate OAuth request, setups callback url"""
        params = {"oauth_callback": self.redirect_uri}
        if extra_params:
            params.update(extra_params)

        if "oauth_verifier" in self.data:
            params["oauth_verifier"] = self.data["oauth_verifier"]
        request = OAuthRequest.from_consumer_and_token(self.consumer, token=token, http_url=url, parameters=params)
        request.sign_request(OAuthSignatureMethod_HMAC_SHA1(), self.consumer, token)
        return request

# 需要导入模块: from oauth.oauth import OAuthRequest [as 别名]
# 或者: from oauth.oauth.OAuthRequest import from_consumer_and_token [as 别名]
def fetch_access_token(request, consumer, request_token, url, parameters=None, 
                        sig_method=None):
  parameters = parameters and parameters or {}
  sig_method = sig_method and sig_method or LocalOAuthSignatureMethod_RSA_SHA1()
 
  logging.info('* Obtain an access token ...')
  oauth_request = OAuthRequest.from_consumer_and_token(
      consumer, request_token, http_url=url, parameters=parameters
      )
  oauth_request.sign_request(sig_method, consumer, None)
  
  return _fetch_token(oauth_request)