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 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 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 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 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 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 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 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 _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 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 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('')
