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() )
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)
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
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)
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))
def _fetch_resource(self, url, parameters=None): """ 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='GET', 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)
def get_authorize_url(self): parameters = {'client_id': GITHUB_CLIENT_ID} oauth_request = OAuthRequest.from_consumer_and_token( self.consumer, http_url=GITHUB_AUTHORIZE_URL, parameters=parameters) return oauth_request.to_url()
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
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)
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
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())
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
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)
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)
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)
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()
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
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() # 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('GET', oa_req.to_url()) 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
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())
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)
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
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)
def oauth_request(self, token, url, extra_params=None): 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(SignatureMethod_HMAC_SHA1(), self.consumer, token) return request
def get_request_token(): oauth_request = OAuthRequest.from_consumer_and_token( consumer, http_method="POST", http_url=REQUEST_TOKEN_URL, callback="oob") oauth_request.sign_request(HMAC(), consumer, "") headers = oauth_request.to_header() client = Http() response, body = client.request(REQUEST_TOKEN_URL, "POST", headers=headers) token = OAuthToken.from_string(body) return token
def exchange_pin_for_access_token(pin, request_token): parameters=dict(oauth_verifier=pin) oauth_request = OAuthRequest.from_consumer_and_token( consumer, request_token, http_method="POST", http_url=ACCESS_TOKEN_URL, parameters=parameters) oauth_request.sign_request(HMAC(), consumer, request_token) headers = oauth_request.to_header() client = Http() response, body = client.request(ACCESS_TOKEN_URL, "POST", headers=headers) token = OAuthToken.from_string(body) return token, body
def sign_request(self, url, method, body, headers): """Sign a request with OAuth credentials.""" # Import oauth here so that you don't need it if you're not going # to use it. Plan B: move this out into a separate oauth module. from oauth.oauth import (OAuthRequest, OAuthConsumer, OAuthToken, OAuthSignatureMethod_PLAINTEXT) consumer = OAuthConsumer(self.consumer_key, self.consumer_secret) token = OAuthToken(self.token_key, self.token_secret) oauth_request = OAuthRequest.from_consumer_and_token( consumer, token, http_url=url) oauth_request.sign_request(OAuthSignatureMethod_PLAINTEXT(), consumer, token) headers.update(oauth_request.to_header(self.oauth_realm))
def get_authorization_url(self, callback=None): """Return the authorization url and token.""" token = self.get_request_token() parameters = dict(application_name=self.application_name) if callback: parameters['oauth_callback'] = callback oauth_request = OAuthRequest.from_consumer_and_token( self.consumer, token=token, parameters=parameters, http_url=self.authorization_url, ) oauth_request.sign_request(self.signature_method, self.consumer, token) return oauth_request.to_url(), token
def fetch_request_token(self): """ Retrieve an unauthorized request token that, in the next step of the OAuth process, will be used to authorize the application. """ try: oauth_request = OAuthRequest.from_consumer_and_token( self._consumer, http_method='POST', http_url=YAMMER_REQUEST_TOKEN_URL) oauth_request.sign_request(self._signature, self._consumer, None) headers = oauth_request.to_header() except OAuthError, m: raise YammerError(m.message)
def redirect(key, secret, request): consumer = OAuthConsumer(str(key), str(secret)) oauth_request = OAuthRequest.from_consumer_and_token( consumer, http_url='https://twitter.com/oauth/request_token') oauth_request.sign_request(SIGNATURE_METHOD(), consumer, None) url = oauth_request.to_url() connection = HTTPSConnection('twitter.com') 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 = 'https://twitter.com/oauth/authorize' 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) if request.is_ajax(): return HttpResponse('<script>document.location = \'%s\';</script>' % oauth_request.to_url()) else: return HttpResponseRedirect(oauth_request.to_url())
def _storeAccessToken(self, result, request): accessToken = OAuthToken.from_string(result) log.msg('Got access token: %s' % accessToken) conf = self._conf consumer = OAuthConsumer(conf.consumer_key, conf.consumer_secret) oaRequest = OAuthRequest.from_consumer_and_token( consumer, token=accessToken, http_url=conf.verify_credentials_url) oaRequest.sign_request( OAuthSignatureMethod_HMAC_SHA1(), consumer, accessToken) log.msg('Verifying credentials.') d = client.getPage(oaRequest.to_url()) d.addCallback(self._storeUser, accessToken, request) d.addErrback(log.err) return d
def oauth_request(self, token, url, extra_params=None): 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(SignatureMethod_HMAC_SHA1(), self.consumer, token) return request
def fetch_request_token(request, consumer, 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 a request token ...') oauth_request = OAuthRequest.from_consumer_and_token(consumer, http_url=url, parameters=parameters) oauth_request.sign_request(sig_method, consumer, None) return _fetch_token(oauth_request)
def exchange_pin_for_access_token(pin, request_token): parameters = dict(oauth_verifier=pin) oauth_request = OAuthRequest.from_consumer_and_token( consumer, request_token, http_method="POST", http_url=ACCESS_TOKEN_URL, parameters=parameters) oauth_request.sign_request(HMAC(), consumer, request_token) headers = oauth_request.to_header() client = Http() response, body = client.request(ACCESS_TOKEN_URL, "POST", headers=headers) token = OAuthToken.from_string(body) return token, body
def _fetch_resource(self, url, params=None, method=None, body=None): if not body and not method or method == 'GET': return Yammer._fetch_resource(self, url, params) if not self._access_token: raise YammerError('missing access token') try: o = OAuthRequest.from_consumer_and_token(self._consumer, token=self._access_token, http_method=method, http_url=url, parameters=params) headers = o.to_header() o.sign_request(self._signature, self._consumer, self._access_token) url = o.to_url() except OAuthError, m: raise YammerError(m.message)
def validate(self, request, data): signature_method = OAuthSignatureMethod_HMAC_SHA1() consumer = OAuthConsumer(self.CONSUMER_KEY, self.CONSUMER_SECRET) try: oauth_token = data['oauth_token'] oauth_verifier = data.get('oauth_verifier', None) except MultiValueDictKeyError: messages.error(request, lang.BACKEND_ERROR) raise Redirect('publicauth-login') oauth_req = OAuthRequest.from_consumer_and_token(consumer, http_url=self.ACCESS_TOKEN_URL) oauth_req.set_parameter('oauth_token', oauth_token) if oauth_verifier: oauth_req.set_parameter('oauth_verifier', oauth_verifier) oauth_req.sign_request(signature_method, consumer, None) response = urllib.urlopen(oauth_req.to_url()).read() self.identity = urlparse.parse_qs(response, keep_blank_values=False)['oauth_token'][0] return response
def get_unauthorised_request_token(self, consumer, connection): from django.contrib.sites.models import Site from django.core.urlresolvers import reverse request = OAuthRequest.from_consumer_and_token( consumer, http_url = self.request_token_url, parameters = { 'oauth_callback': 'http://%s%s' % ( Site.objects.get_current().domain, reverse('megaphone_callback') ) } ) request.sign_request(self.signature_method, consumer, None) resp = self.fetch_response(request, connection) token = OAuthToken.from_string(resp) return token
def _fetch_resource(self, url, params=None, method=None, body=None): if not body and not method or method == 'GET': return Yammer._fetch_resource(self, url, params) if not self._access_token: raise YammerError('missing access token') try: o = OAuthRequest.from_consumer_and_token( self._consumer, token=self._access_token, http_method=method, http_url=url, parameters=params) headers = o.to_header() o.sign_request(self._signature, self._consumer, self._access_token) url = o.to_url() except OAuthError, m: raise YammerError(m.message) try: self._connection.request(o.http_method, url, body=body, headers=headers) except socket.gaierror, (n, m): raise YammerError(m)
def authorize(self, token): """Authorize a user with netflix and return a user id and an access token.""" oa_req = OAuthRequest.from_consumer_and_token( self.consumer, token=token, parameters={'application_name': self.application_name} if self.application_name else None, http_url=self.access_token_url) oa_req.sign_request(self.signature_method, self.consumer, token) req = self.http.get_url(oa_req.to_url()) if not str(req.status).startswith('2'): self.analyze_error(req) res = req.data logging.debug(res) id = cgi.parse_qs(res)['user_id'][0] return id, OAuthToken.from_string(res)
def validate(self, request, data): signature_method = OAuthSignatureMethod_HMAC_SHA1() consumer = OAuthConsumer(self.CONSUMER_KEY, self.CONSUMER_SECRET) try: oauth_token = data['oauth_token'] oauth_verifier = data.get('oauth_verifier', None) except MultiValueDictKeyError: messages.error(request, lang.BACKEND_ERROR) raise Redirect('publicauth-login') oauth_req = OAuthRequest.from_consumer_and_token( consumer, http_url=self.ACCESS_TOKEN_URL) oauth_req.set_parameter('oauth_token', oauth_token) if oauth_verifier: oauth_req.set_parameter('oauth_verifier', oauth_verifier) oauth_req.sign_request(signature_method, consumer, None) response = urllib.urlopen(oauth_req.to_url()).read() self.identity = urlparse.parse_qs( response, keep_blank_values=False)['oauth_token'][0] return response
def request(self, method, params): consumer = OAuthConsumer(self.config["tellstick"]["public_key"], self.config["tellstick"]["private_key"]) token = OAuthToken(self.config["tellstick"]["token"], self.config["tellstick"]["token_secret"]) oauth_request = OAuthRequest.from_consumer_and_token( consumer, token=token, http_method="GET", http_url="http://api.telldus.com/json/" + method, parameters=params, ) oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(), consumer, token) headers = oauth_request.to_header() headers["Content-Type"] = "application/x-www-form-urlencoded" conn = httplib.HTTPConnection("api.telldus.com:80") conn.request("GET", "/json/" + method + "?" + urlencode(params, True).replace("+", "%20"), headers=headers) response = conn.getresponse() return json.load(response)
def post_url(self, url, token, *args, **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 = 'POST', http_url = url, parameters = kwargs ) request.sign_request(self.signature_method, consumer, token) connection.request( request.http_method, request.to_url(), ''.join(args) ) resp = connection.getresponse().read() return StringIO(resp)
def render_GET(self, request): """ Handles a callback GET request. """ log.err('Callback received: %s' % request) oauthToken = request.args['oauth_token'] if oauthToken: oauthToken = oauthToken[0] else: log.err('Received callback with no oauth_token: %s' % request) raise Exception('Received callback with no oauth_token.') oauthVerifier = request.args['oauth_verifier'] if oauthVerifier: oauthVerifier = oauthVerifier[0] else: log.err('Received callback with no oauth_verifier: %s' % request) raise Exception('Received callback with no oauth_verifier.') try: token = self._oauthTokenDict.pop(oauthToken) except KeyError: log.err('Received callback with unknown oauth_token: %s' % oauthToken) raise Exception('Received callback with unknown oauth_token.') conf = self._conf consumer = OAuthConsumer(conf.consumer_key, conf.consumer_secret) oaRequest = OAuthRequest.from_consumer_and_token( consumer, token=token, verifier=oauthVerifier, http_url=conf.access_token_url) oaRequest.sign_request( OAuthSignatureMethod_HMAC_SHA1(), consumer, token) log.msg('Requesting access token.') d = client.getPage(oaRequest.to_url(), headers=oaRequest.to_header()) d.addCallback(self._storeAccessToken, request) d.addErrback(log.err) return server.NOT_DONE_YET
def authorize(self, token): """Authorize a user with netflix and return a user id and an access token.""" oa_req = OAuthRequest.from_consumer_and_token( self.consumer, token=token, parameters={'application_name': self.application_name} if self.application_name else None, http_url=self.access_token_url ) oa_req.sign_request( self.signature_method, self.consumer, token ) req = self.http.get_url(oa_req.to_url()) if not str(req.status).startswith('2'): self.analyze_error(req) res = req.data logging.debug(res) id = cgi.parse_qs(res)['user_id'][0] return id, OAuthToken.from_string(res)
def callback(key, secret, request): token = request.session.get('unauth_token') if not token: raise Exception('No unauthorised token') if token.key != request.GET.get('oauth_token', None): raise Exception('Token does not match') verifier = request.GET.get('oauth_verifier') consumer = OAuthConsumer(str(key), str(secret)) oauth_request = OAuthRequest.from_consumer_and_token( consumer, token=token, http_url='https://twitter.com/oauth/access_token', parameters={'oauth_verifier': verifier}) oauth_request.sign_request(SIGNATURE_METHOD(), consumer, token) url = oauth_request.to_url() access_token = OAuthToken.from_string(urlopen(url).read()) return access_token
def swap_tokens(self, *args, **kwargs): if self.token_required: consumer, token = args token = OAuthToken.from_string(token) request = OAuthRequest.from_consumer_and_token( consumer, token = token, http_url = self.access_token_url, parameters = kwargs ) request.sign_request(self.signature_method, consumer, token) url = request.to_url() if url.startswith('http://'): url = url[7:] elif url.startswith('https://'): url = url[8:] if url.startswith(self.server): url = url[len(self.server):] q = url.find('?') if q > 01: qs = url[q + 1:] url = url[:q] else: qs = '' connection = self.get_connection(False) connection.request(request.http_method, url, qs, request.to_header()) resp = connection.getresponse().read() return OAuthToken.from_string(resp) else: raise NotImplementedError('Method not implemented for non-standard OAuth provider.')
def return_auth(request, site): creds = OAUTH_CREDENTIALS.get(site.upper()) if not creds: raise Http404('Site %s not found' % site) urls = creds.get('URLS', {}) ssl = creds.get('SSL', False) server = creds.get('SERVER', '%s.com' % site.lower()) if not 'DIALOG' in urls: token = request.session.get('unauth_token') if not token: return HttpResponse('No unauthorised token') if token.key != request.GET.get('oauth_token', None): if request.session.get('preauth_url'): return HttpResponseRedirect( request.session['preauth_url'] ) else: return HttpResponse('') verifier = request.GET.get('oauth_verifier') consumer = OAuthConsumer( str(creds.get('CONSUMER_KEY')), str(creds.get('CONSUMER_SECRET')) ) oauth_request = OAuthRequest.from_consumer_and_token( consumer, token = token, http_url = urls.get('ACCESS_TOKEN'), parameters = { 'oauth_verifier': verifier } ) oauth_request.sign_request(SIGNATURE_METHOD(), consumer, token) url = oauth_request.to_url() access_token = OAuthToken.from_string( urlopen(url).read() ) if request.user.is_authenticated(): try: token = request.user.oauth_tokens.get( site = site ) token.token = access_token.key token.secret = access_token.secret token.save() except core.OAuthToken.DoesNotExist: request.user.oauth_tokens.create( site = site, token = access_token.key, secret = access_token.secret ) else: return HttpResponse('') else: url = urls.get('ACCESS_TOKEN') % request.GET.get('code') resp = urlopen(url).read() d = {} for (key, value) in [i.split('=') for i in resp.split('&')]: if key: d[key] = value if request.user.is_authenticated(): try: token = request.user.oauth_tokens.get( site = site ) token.token = d['access_token'] token.save() except core.OAuthToken.DoesNotExist: request.user.oauth_tokens.create( site = site, token = d['access_token'] ) else: return HttpResponse('') if request.session.get('preauth_url'): messages.add_message( request, messages.SUCCESS, u'You have been successfully connected to %s.' % creds.get( 'VERBOSE_NAME', site.capitalize() ) ) return HttpResponseRedirect( request.session['preauth_url'] ) else: return HttpResponse('')