def build(http_url, token, http_method='GET'):
# build and return oauth request url
match = re.match('(.+):(.+)@(.+)', token)
try:
token = oauth.OAuthToken(
match.group(1),
match.group(2)
)
except Exception:
raise InvalidAccessToken('the provided access token is invalid.')
url = BASE_API_URI + http_url
if not consumer_key:
raise MissingKeyError('provide consumer key')
if not consumer_secret:
raise MissingKeyError('provide consumer consumer_secret')
oauth_consumer = oauth.OAuthConsumer(consumer_key, consumer_secret)
request = OAuthRequest.from_consumer_and_token(
oauth_consumer,
http_url=url,
token=token,
http_method=http_method,
parameters={}
)
request.sign_request(SIGNATURE_METHOD, oauth_consumer, token)
return request.to_url()
def createOauthRequest(http_url, params, default_params):
validateOptions(params, default_params)
default_params.update(params)
params = default_params
http_method = 'GET'
token = params.pop('token', None)
base_url = 'https://www.pesapal.com/api/'
if testing:
base_url = 'https://demo.pesapal.com/api/'
url = base_url + http_url
if not consumer_key:
raise MissingKeyError('provide consumer key')
if not consumer_secret:
raise MissingKeyError('provide consumer consumer_secret')
oauth_consumer = oauth.OAuthConsumer(consumer_key, consumer_secret)
request = OAuthRequest.from_consumer_and_token(oauth_consumer,
http_url=url,
http_method=http_method,
parameters=params)
request.sign_request(SIGNATURE_METHOD, oauth_consumer, token)
return request.to_url()
def load(self, url, method="GET", parameters=None, raw=False):
oauth_request = OAuthRequest.from_consumer_and_token(self.consumer,
token=self.access_token, http_url=url, http_method=method,
parameters=parameters)
oauth_request.sign_request(self.signature_method, self.consumer,
self.access_token)
return self.oauth_fetch(oauth_request, raw)
def access_resource(self,
relative_url,
access_token,
method="GET",
params=None):
full_url = self.server_url + relative_url
url = urlparse.urlparse(full_url)
full_params = cgi.parse_qs(url.query)
for key in full_params:
full_params[key] = full_params[key][0]
if params:
full_params.update(params)
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
token=access_token,
http_url=full_url,
parameters=full_params,
http_method=method)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(),
self.consumer, access_token)
if method == "GET":
response = get_response(oauth_request.to_url())
else:
response = post_response(full_url, oauth_request.to_postdata())
return response
def make_api_request(access_token, url, data=None):
# break down the url, as we'll need to later
request_type, host, port, path = _split_server_parts(url)
parameters = {
'oauth_consumer_key': settings.CODA_KEY,
'oauth_token': access_token.key,
'oauth_signature_method': 'HMAC-SHA1',
'oauth_timestamp': str(int(time.time())),
'oauth_nonce': os.urandom(10).encode('hex'),
'oauth_version': '1.0',
'format': 'json',
}
# data should be a dict of things
if data:
for k in data.keys():
parameters[k] = data[k]
newurl = '%s://%s:%d%s' % (request_type, host, port, path)
#newurl = '%s://%s%s' % (request_type, host, port, path)
oauth_request = OAuthRequest.from_token_and_callback(access_token,
http_method="POST",
http_url=newurl,
parameters=parameters)
signature_method = OAuthSignatureMethod_HMAC_SHA1()
consumer = OAuthConsumer(settings.CODA_KEY, settings.CODA_SECRET)
access_token_t = OAuthToken(access_token.key, access_token.secret)
signature = signature_method.build_signature(oauth_request, consumer,
access_token_t)
parameters['oauth_signature'] = signature
if request_type == 'http':
conn = httplib.HTTPConnection(host, port)
else:
conn = httplib.HTTPSConnection(host, port)
conn.putrequest('POST', path)
data = ''
for key in parameters.keys():
data += '%s=%s&' % (key, urllib.quote(parameters[key]))
data = data[:-1]
print data
conn.putheader('content-length', str(len(data)))
conn.endheaders()
conn.send(data)
conn.send('\n\r\n\r')
resp = conn.getresponse()
data = resp.read()
print data
return simplejson.loads(data)
def access_resource(self,
relative_url,
access_token,
method="GET",
params=None):
full_url = self.server_url + relative_url
url = urlparse.urlparse(full_url)
full_params = cgi.parse_qs(url.query)
for key in full_params:
full_params[key] = full_params[key][0]
if params:
full_params.update(params)
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
token = access_token,
http_url = full_url,
parameters = full_params,
http_method=method
)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(), self.consumer, access_token)
if method == "GET":
response = get_response(oauth_request.to_url())
else:
response = post_response(full_url, oauth_request.to_postdata())
return response
def access_api_resource(self, relative_url, access_token, method="GET"):
full_url = self.server_url + relative_url
# Escape each parameter value.
url = urlparse.urlparse(full_url)
query_params = cgi.parse_qs(url.query)
for key in query_params:
query_params[key] = query_params[key][0]
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
token=access_token,
http_url=full_url,
parameters=query_params,
http_method=method)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(),
self.consumer, access_token)
file = None
ret = None
try:
if method == "GET":
file = urllib2.urlopen(oauth_request.to_url())
else:
file = urllib2.urlopen(url.path, oauth_request.to_postdata())
except urllib2.HTTPError, error:
# We don't want to treat HTTP error codes (401, 404, etc.) like
# exceptional scenarios. We want to pass them along like anything
# else.
# Luckily, the exception raised here acts very much like an
# `HTTPResponse` object. Good enough for our purposes.
file = error
def start_fetch_request_token(self):
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer, http_url="%s/api/auth/request_token" % self.server_url
)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(), self.consumer, None)
webbrowser.open(oauth_request.to_url())
def createOauthRequest(http_url, params, default_params):
validateOptions(params, default_params)
default_params.update(params)
params = default_params
http_method = "GET"
token = params.pop("token", None)
base_url = "https://www.pesapal.com/api/"
if testing:
base_url = "https://demo.pesapal.com/api/"
url = base_url + http_url
if not consumer_key:
raise MissingKeyError("provide consumer key")
if not consumer_secret:
raise MissingKeyError("provide consumer consumer_secret")
oauth_consumer = oauth.OAuthConsumer(consumer_key, consumer_secret)
request = OAuthRequest.from_consumer_and_token(
oauth_consumer, http_url=url, http_method=http_method, parameters=params
)
request.sign_request(SIGNATURE_METHOD, oauth_consumer, token)
return request.to_url()
def make_request_token_and_authorization_url(self, callback_url):
response = self.get("/oauth/request_token", prefix="").read()
print response
token = OAuthToken.from_string(response)
request = OAuthRequest.from_token_and_callback(token=token, callback=callback_url, http_url='http://%s/oauth/authorize' % self.authority)
return [token, request.to_url()]
def execute(self, url, params, consumer, access_token, method='POST', mode='header'):
headers = {}
headers.setdefault('User-Agent', "python")
headers.setdefault("Accept", "text/html")
headers.setdefault("Content-Type", "application/x-www-form-urlencoded")
request = OAuthRequest.from_consumer_and_token(
self.consumer,
http_url=url,
http_method=method,
token=access_token,
parameters=params,
)
request.sign_request(OAuthSignatureMethod_HMAC_SHA1(), consumer, access_token)
if mode == 'header':
headers.update(request.to_header())
else:
url = request.get_normalized_http_url()
params = request.to_postdata()
multipart_encode({})
host, path = _url_spllit(url)
conn = httplib.HTTPConnection(host)
conn.request(method, path, params, headers)
resp = conn.getresponse()
json = resp.read()
conn.close()
return json
def build_oauth_request(self, http_url, token=None,
http_method="GET", parameters=None):
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer, token=token, http_method=http_method,
http_url=http_url, parameters=parameters
)
oauth_request.sign_request(self.signature_method, self.consumer, token)
return oauth_request
def start_fetch_request_token(self):
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
http_url="%s/api/auth/request_token" % self.server_url)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(),
self.consumer, None)
webbrowser.open(oauth_request.to_url())
def login():
oauth_request = OAuthRequest.from_consumer_and_token(
consumer,
callback='http://127.0.0.1:5000/oauth_callback',
http_url='http://www.khanacademy.org/api/auth/request_token'
)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(), consumer, None)
return redirect(oauth_request.to_url())
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
def start_fetch_request_token(self, callback=None):
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
callback=callback,
http_url="%s/api/auth/request_token" % self.server_url)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(),
self.consumer, None)
return oauth_request.to_url()
def get_auth_url(self):
""" """
request = OAuthRequest.from_consumer_and_token(
self.consumer,
http_url = self.request_token_url,
callback = self.callback)
request.sign_request(OAuthSignatureMethod_HMAC_SHA1(), self.consumer, None)
resp = urllib2.urlopen(urllib2.Request( request.to_url()))
token = resp.read()
request_token = OAuthToken.from_string(token)
self.request_token = request_token
request = OAuthRequest.from_token_and_callback(
token=request_token, http_url=self.authenticate_url,
callback = self.callback
)
return request.to_url()
def start_fetch_request_token(self, callback=None):
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
callback=callback,
http_url="%s/api/auth/request_token" % self.server_url
)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(), self.consumer, None)
return oauth_request.to_url()
def get(self, path, token=None, prefix="/api"):
url = "http://%s%s%s" % (self.host, prefix, path)
request = OAuthRequest.from_consumer_and_token(
self.consumer,
token,
http_method='GET',
http_url=url
)
return self._send_request(request, token)
def get(self, path, token=None, prefix="/api"):
url = "http://%s%s%s" % (self.host, prefix, path)
request = OAuthRequest.from_consumer_and_token(
self.consumer,
token,
http_method='GET',
http_url=url
)
return self._send_request(request, token)
def post(self, path, post_params, token=None, prefix="/api"):
url = "http://%s%s%s" % (self.host, prefix, path)
request = OAuthRequest.from_consumer_and_token(
self.consumer,
token,
http_method='POST',
http_url=url,
parameters=post_params
)
return self._send_request(request, token)
def post(self, path, post_params, token=None, prefix="/api"):
url = "http://%s%s%s" % (self.host, prefix, path)
request = OAuthRequest.from_consumer_and_token(
self.consumer,
token,
http_method='POST',
http_url=url,
parameters=post_params
)
return self._send_request(request, token)
def start_fetch_request_token(self, callback=None):
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
callback=callback,
http_url="%s/api/auth/request_token" % self.server_url
)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(), self.consumer, None)
print 'opening webbrowser with', oauth_request.to_url()
webbrowser.open(oauth_request.to_url())
def netflix_movie_from_title(cur_movie, only_id=False):
movie = Movies()
if cur_movie and cur_movie.Title and cur_movie.Year:
try:
# Query netflix search API with OAuth
consumer = {
"oauth_token": settings.API_KEYS["NETFLIX"],
"oauth_token_secret": settings.API_KEYS["NETFLIX_SECRET"],
}
params = {"term": cur_movie.Title, "start_index": 0, "max_results": 5}
request = OAuthRequest("http://api-public.netflix.com/catalog/titles", "GET", params)
request.sign_request(OAuthSignatureMethod_HMAC_SHA1, consumer)
url = request.to_url(include_oauth=True)
req = urllib2.Request(url)
res = urllib2.urlopen(req)
if res.getcode() == 200:
# Parse xml response
dom = parseString(res.read())
for node in dom.getElementsByTagName("catalog_title"):
# If year is the same
if (
node.getElementsByTagName("release_year")
and node.getElementsByTagName("release_year")[0]
and abs(cur_movie.Year - int(node.getElementsByTagName("release_year")[0].childNodes[0].data))
< 1
):
if node.getElementsByTagName("id") and node.getElementsByTagName("id")[0]:
if only_id:
return {
"id": netflix_id_from_input(
str(node.getElementsByTagName("id")[0].childNodes[0].data)
)
}
else:
return movie_from_netflix_input(node.getElementsByTagName("id")[0].childNodes[0].data)
return {"error_msg": "Invalid"}
else:
return {"error_msg": "Invalid"}
except Exception:
return {"error_msg": "Netflix API failed, please try again"}
else:
return {"error_msg": "No title to search from."}
def url_for_request_token(self, callback=None, parameters=None):
http_url = "%s/api/auth/request_token" % self.server_url
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
http_url=http_url,
callback=callback,
parameters=parameters)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(),
self.consumer, None)
return oauth_request.to_url()
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)
def _get_authorize_request(self):
params = {}
if self.desktop:
url = self._url_autorize
params['oauth_callback'] = 'oob'
else:
url = self._url_authenticate
if self.force_login:
params['force_login'] = '******'
return OAuthRequest.from_consumer_and_token(self.consumer,
token=self.token,
http_url=url,
parameters=params)
def url_for_request_token(self, callback=None, parameters=None):
http_url = "%s/api/auth/request_token" % self.server_url
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
http_url = http_url,
callback = callback,
parameters = parameters
)
oauth_request.sign_request(
OAuthSignatureMethod_HMAC_SHA1(), self.consumer, None
)
return oauth_request.to_url()
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)
def get_netflix_dom(netflix_id, href=None):
try:
# Query netflix API using OAuth
consumer = {
"oauth_token": settings.API_KEYS["NETFLIX"],
"oauth_token_secret": settings.API_KEYS["NETFLIX_SECRET"],
}
request = None
if href:
request = OAuthRequest(href)
else:
request = OAuthRequest("http://api-public.netflix.com/catalog/titles/movies/" + netflix_id)
request.sign_request(OAuthSignatureMethod_HMAC_SHA1, consumer)
url = request.to_url(include_oauth=True)
req = urllib2.Request(url)
res = urllib2.urlopen(req)
if res.getcode() == 200:
# Parse xml response
return parseString(res.read())
else:
return {"Response": False}
except Exception:
return {"Response": False}
def post_resources(self,
relative_url,
access_token,
method="POST",
data=None,
content_type=None):
full_url = self.server_url + relative_url
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
token=access_token,
http_url=full_url,
http_method=method)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(),
self.consumer, access_token)
return post_response(oauth_request.to_url(), data, content_type)
def getOauthRequest(self, http_url, params, default_params):
self.validateOptions(params, default_params)
default_params.update(params)
params = default_params
http_method = 'GET'
token = params.pop('token', None)
url = self.base_url + http_url
request = OAuthRequest.from_consumer_and_token(self.oauth_consumer,
http_url=url,
http_method=http_method,
parameters=params)
request.sign_request(SIGNATURE_METHOD, self.oauth_consumer, token)
return request
def url_for_access_token(self, request_token, callback=None, parameters=None, verifier=None):
http_url = "%s/api/auth/access_token" % self.server_url
if not verifier and request_token.verifier:
verifier = request_token.verifier
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
token = request_token,
http_url = http_url,
callback = callback,
parameters = parameters,
verifier = verifier
)
oauth_request.sign_request(
OAuthSignatureMethod_HMAC_SHA1(), self.consumer, request_token
)
return oauth_request.to_url()
def post_resources(self,
relative_url,
access_token,
method="POST",
data=None,
content_type=None):
full_url = self.server_url + relative_url
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
token=access_token,
http_url=full_url,
http_method=method
)
oauth_request.sign_request(
OAuthSignatureMethod_HMAC_SHA1(), self.consumer, access_token)
return post_response(oauth_request.to_url(), data, content_type)
def getOauthRequest(self, http_url, params, default_params):
self.validateOptions(params, default_params)
default_params.update(params)
params = default_params
http_method='GET'
token = params.pop('token', None)
url = self.base_url + http_url
request = OAuthRequest.from_consumer_and_token(
self.oauth_consumer,
http_url= url,
http_method=http_method,
parameters=params
)
request.sign_request(SIGNATURE_METHOD, self.oauth_consumer, token)
return request
def oauth_callback():
oauth_token = request.args.get("oauth_token", "")
oauth_secret = request.args.get("oauth_token_secret", "")
oauth_verifier = request.args.get("oauth_verifier", "")
request_token = OAuthToken(oauth_token, oauth_secret)
request_token.set_verifier(oauth_verifier)
session["request_token"] = request_token.to_string()
oauth_request = OAuthRequest.from_consumer_and_token(
consumer,
token=request_token,
http_url='http://www.khanacademy.org/api/auth/access_token',
callback=None,
parameters=None,
verifier=request_token.verifier
)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(), consumer, request_token)
r = requests.get(oauth_request.to_url())
access_token = OAuthToken.from_string(r.text)
session['oauth_token'] = access_token.to_string()
return redirect(url_for("index"))
def url_for_access_token(self,
request_token,
callback=None,
parameters=None,
verifier=None):
http_url = "%s/api/auth/access_token" % self.server_url
if not verifier and request_token.verifier:
verifier = request_token.verifier
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
token=request_token,
http_url=http_url,
callback=callback,
parameters=parameters,
verifier=verifier)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(),
self.consumer, request_token)
return oauth_request.to_url()
def access_resource(self, relative_url, access_token):
full_url = self.server_url + relative_url
url = urlparse.urlparse(full_url)
query_params = cgi.parse_qs(url.query)
for key in query_params:
query_params[key] = query_params[key][0]
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
token = access_token,
http_url = full_url,
parameters = query_params
)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(), self.consumer, access_token)
response = get_response(oauth_request.to_url())
return response.strip()
def access_resource(self, relative_url, access_token):
full_url = self.server_url + relative_url
url = urlparse.urlparse(full_url)
query_params = cgi.parse_qs(url.query)
for key in query_params:
query_params[key] = query_params[key][0]
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
token=access_token,
http_url=full_url,
parameters=query_params)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(),
self.consumer, access_token)
response = get_response(oauth_request.to_url())
return response.strip()
def index():
access_token = session.get('oauth_token')
if access_token is None:
return redirect(url_for('login'))
full_url='http://www.khanacademy.org/api/v1/user'
url=urlparse.urlparse(full_url)
query_params = cgi.parse_qs(url.query)
for key in query_params:
query_params[key] = query_params[key][0]
token=OAuthToken.from_string(access_token)
oauth_request = OAuthRequest.from_consumer_and_token(
consumer,
token=token,
http_url='http://www.khanacademy.org/api/v1/user',
parameters=query_params,
http_method='GET'
)
oauth_request.sign_request(OAuthSignatureMethod_HMAC_SHA1(), consumer, token)
r = requests.get(oauth_request.to_url()).content
data=json.loads(r)
return render_template("index.html", email=str(data['student_summary']['email']))
def access_api_resource(self, relative_url, access_token, method="GET"):
full_url = self.server_url + urllib2.quote(relative_url)
print "full_url %s" % full_url
# Escape each parameter value.
url = urlparse.urlparse(full_url)
query_params = cgi.parse_qs(url.query)
for key in query_params:
query_params[key] = query_params[key][0]
oauth_request = OAuthRequest.from_consumer_and_token(
self.consumer,
token = access_token,
http_url = full_url,
parameters = query_params,
http_method = method
)
oauth_request.sign_request(
OAuthSignatureMethod_HMAC_SHA1(), self.consumer, access_token
)
file = None
ret = None
try:
if method == "GET":
file = urllib2.urlopen(oauth_request.to_url())
else:
file = urllib2.urlopen(url.path, oauth_request.to_postdata())
except urllib2.HTTPError, error:
# We don't want to treat HTTP error codes (401, 404, etc.) like
# exceptional scenarios. We want to pass them along like anything
# else.
# Luckily, the exception raised here acts very much like an
# `HTTPResponse` object. Good enough for our purposes.
file = error
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)
def http(self, method, url, params, filedatas=None):
headers = {}
headers.setdefault('User-Agent', "BAYE.ME social comment")
# headers.setdefault("Accept", "text/html")
self._process_params(params)
request = OAuthRequest.from_consumer_and_token(
self.consumer,
http_url=url,
http_method=method,
token=self.access_token,
parameters=params
)
request.sign_request(
OAuthSignatureMethod_HMAC_SHA1(), self.consumer,
self.access_token
)
if method == 'POST':
url = request.get_normalized_http_url()
else:
url = request.to_url()
signed_params = request.to_postdata()
if filedatas:
_params = urlparse.parse_qs(signed_params, keep_blank_values=True)
content_type, body = self.encode_multipart(_params, filedatas)
else:
content_type, body = "application/x-www-form-urlencoded", signed_params
headers.setdefault("Content-Type", content_type)
host, path = _split_url(url)
conn = httplib.HTTPConnection(host)
conn.request(method, path, body, headers)
resp = conn.getresponse()
json = resp.read()
conn.close()
return self._process_result(json)
def get_authorization_url(self, request_token):
url = API_HOME + '/oauth/authorize'
request = OAuthRequest.from_token_and_callback(request_token,
http_url=url)
return request.to_url()
