def set_verifier(self, oauth_verifier):
if self.request_token is None:
raise AuthHandlerError(
"Request token is not defined. This ususally means that the access token has been loaded from a file."
)
self.request_token.set_verifier(oauth_verifier)
access_token_parms = {
'oauth_consumer_key': self.key,
'oauth_nonce': oauth.generate_nonce(),
'oauth_signature_method': "HMAC-SHA1",
'oauth_timestamp': str(int(time.time())),
'oauth_token': self.request_token.key,
'oauth_verifier': self.request_token.verifier
}
req = oauth.OAuthRequest(http_method="GET",
http_url=ACCESS_TOKEN_URL,
parameters=access_token_parms)
req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(), self.consumer,
self.request_token)
resp = urllib2.urlopen(req.to_url())
access_token_resp = dict(urlparse.parse_qsl(resp.read()))
self.access_token = oauth.OAuthToken(
access_token_resp["oauth_token"],
access_token_resp["oauth_token_secret"])
def request(url, params=None, consumer=None, token=None):
oauth_params = {
'oauth_version': "1.0",
'oauth_nonce': oauth.generate_nonce(),
'oauth_timestamp': int(time.time()),
'oauth_consumer_key': consumer.key,
}
if token:
oauth_params['oauth_token'] = token.key
if params:
oauth_params.update(params)
request = oauth.OAuthRequest(http_method="GET",
http_url=url,
parameters=oauth_params)
request.sign_request(SIGNATURE_METHOD, consumer, token)
url = request.to_url()
encoded_post_data = ""
http = httplib2.Http()
if encoded_post_data:
response, content = http.request(url,
http_method,
body=encoded_post_data)
else:
response, content = http.request(url, "GET")
return response, content
def oauth_headers(url, consumer_key, token_key, token_secret, consumer_secret):
consumer = oauth.OAuthConsumer(consumer_key, consumer_secret)
token = oauth.OAuthToken(token_key, token_secret)
params = {
'oauth_version': "1.0",
'oauth_nonce': oauth.generate_nonce(),
'oauth_timestamp': int(time.time()),
'oauth_token': token.key,
'oauth_consumer_key': consumer.key,
}
req = oauth.OAuthRequest(http_url=url, parameters=params)
req.sign_request(oauth.OAuthSignatureMethod_PLAINTEXT(),
consumer, token)
return(req.to_header())
def __init__(self,
key=None,
secret=None,
callback=None,
access_token_key=None,
access_token_secret=None,
request_token_key=None,
request_token_secret=None):
self.key = key or keys.API_KEY
self.secret = secret or keys.API_SECRET
if self.key is None or self.secret is None:
raise ValueError("API keys have not been set.")
if callback is None:
callback = ("https://api.flickr.com/services/rest/"
"?method=flickr.test.echo&api_key=%s" % self.key)
params = {
'oauth_timestamp': str(int(time.time())),
'oauth_signature_method': "HMAC-SHA1",
'oauth_version': "1.0",
'oauth_callback': callback,
'oauth_nonce': oauth.generate_nonce(),
'oauth_consumer_key': self.key
}
self.consumer = oauth.OAuthConsumer(key=self.key, secret=self.secret)
if (access_token_key is None) and (request_token_key is None):
req = oauth.OAuthRequest(http_method="GET",
http_url=TOKEN_REQUEST_URL,
parameters=params)
req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(),
self.consumer, None)
resp = urllib2.urlopen(req.to_url())
request_token = dict(urlparse.parse_qsl(resp.read()))
self.request_token = oauth.OAuthToken(
request_token['oauth_token'],
request_token['oauth_token_secret'])
self.access_token = None
elif request_token_key is not None:
self.access_token = None
self.request_token = oauth.OAuthToken(request_token_key,
request_token_secret)
else:
self.request_token = None
self.access_token = oauth.OAuthToken(access_token_key,
access_token_secret)
def get_oauth_request_header(
self,
method,
parameters,
data,
consumer_key,
consumer_secret,
content_type=oauth.HTTPRequest.FORM_URLENCODED_TYPE):
if isinstance(data, dict) and isinstance(parameters, dict):
data.update(parameters)
data = urllib.urlencode(data)
http_request = oauth.HTTPRequest(method, self.url.base + self.url.path,
content_type, data, {})
oauth_request = oauth.OAuthRequest(
self.get_consumer(consumer_key, consumer_secret), self.get_token(),
http_request, {})
# Sign the request
oauth_request.sign(oauth.OAuthSignatureMethod_HMAC_SHA1())
return oauth_request.to_header(with_content_type=True)
def complete_parameters(self, url, params={}, exclude_signature=[]):
defaults = {
'oauth_timestamp': str(int(time.time())),
'oauth_nonce': oauth.generate_nonce(),
'signature_method': "HMAC-SHA1",
'oauth_token': self.access_token.key,
'oauth_consumer_key': self.consumer.key,
}
excluded = {}
for e in exclude_signature:
excluded[e] = params.pop(e)
defaults.update(params)
req = oauth.OAuthRequest(http_method="POST", http_url=url,
parameters=defaults)
req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(), self.consumer,
self.access_token)
req.parameters.update(excluded)
return req
def oauth_headers(url,
consumer_key,
token_key,
token_secret,
consumer_secret,
clockskew=0):
"""Build OAuth headers using given credentials."""
consumer = oauth.OAuthConsumer(consumer_key, consumer_secret)
token = oauth.OAuthToken(token_key, token_secret)
timestamp = int(time.time()) + clockskew
params = {
'oauth_version': "1.0",
'oauth_nonce': oauth.generate_nonce(),
'oauth_timestamp': timestamp,
'oauth_token': token.key,
'oauth_consumer_key': consumer.key,
}
req = oauth.OAuthRequest(http_url=url, parameters=params)
req.sign_request(oauth.OAuthSignatureMethod_PLAINTEXT(), consumer, token)
return (req.to_header())
def _call_oauth_ws(self, url, params=None, http_method="GET"):
oauth_base_params = {
'oauth_version': "1.0",
'oauth_nonce': oauth.generate_nonce(),
'oauth_timestamp': int(time.time()),
'oauth_consumer_key': self._consumer_key,
'oauth_token': self._oauth_token
}
if params:
params.update(oauth_base_params)
else:
params = oauth_base_params
request = oauth.OAuthRequest(http_method=http_method,
http_url=url,
parameters=params)
request.sign_request(self._signature_method, self._consumer,
self._access_token)
if http_method == "POST" or http_method == "PUT":
encoded_post_data = request.to_postdata()
else:
url = request.to_url()
encoded_post_data = ""
http = httplib2.Http()
if encoded_post_data:
response, content = http.request(url,
http_method,
body=encoded_post_data)
else:
response, content = http.request(url, "GET")
if response["status"] != '200':
raise Exception(response.reason)
return content
def on_buzz_auth_clicked(self, widget, data=None):
self.winsize = self.window.get_size()
web = webkit.WebView()
web.get_settings().set_property("enable-plugins", False)
web.load_html_string(_("<p>Please wait...</p>"), "file:///")
self.consumer = oauth.OAuthConsumer("anonymous", "anonymous")
params = {
"oauth_consumer_key": self.consumer.key,
"oauth_timestamp": oauth.generate_timestamp(),
"oauth_nonce": oauth.generate_nonce(),
"oauth_version": oauth.OAuthRequest.version,
"oauth_callback": "http://gwibber.com/0/auth.html",
"scope": "https://www.googleapis.com/auth/buzz",
}
request = oauth.OAuthRequest("POST", "https://www.google.com/accounts/OAuthGetRequestToken", params)
request.sign_request(sigmeth, self.consumer, token=None)
tokendata = urllib2.urlopen(request.http_url, request.to_postdata()).read()
self.token = oauth.OAuthToken.from_string(tokendata)
url = "https://www.google.com/accounts/OAuthAuthorizeToken?oauth_token=" + self.token.key
web.open(url)
web.set_size_request(450, 340)
web.connect("title-changed", self.on_buzz_auth_title_change)
scroll = gtk.ScrolledWindow()
scroll.add(web)
self.pack_start(scroll, True, True, 0)
self.show_all()
self.ui.get_object("vbox1").hide()
self.ui.get_object("expander1").hide()
def get_oauth_header(url, oauth_data=None):
if oauth_data:
oauth_consumer_secret = ""
oauth_consumer_key = oauth_data[2]
oauth_token_key = oauth_data[0]
oauth_token_secret = oauth_data[1]
consumer = oauth.OAuthConsumer(oauth_consumer_key,
oauth_consumer_secret)
token = oauth.OAuthToken(oauth_token_key, oauth_token_secret)
p = {
'oauth_version': "1.0",
'oauth_nonce': oauth.generate_nonce(),
'oauth_timestamp': int(time.time()),
'oauth_token': token.key,
'oauth_consumer_key': consumer.key,
}
req = oauth.OAuthRequest(http_url=url, parameters=p)
req.sign_request(oauth.OAuthSignatureMethod_PLAINTEXT(), consumer,
token)
return req.to_header()
def __init__(self,
key=API_KEY,
secret=API_SECRET,
callback=None,
access_token_key=None,
access_token_secret=None):
if callback is None:
callback = "http://api.flickr.com/services/rest/?method=flickr.test.echo&api_key=%s" % key
self.key = key
self.secret = secret
params = {
'oauth_timestamp': str(int(time.time())),
'oauth_signature_method': "HMAC-SHA1",
'oauth_version': "1.0",
'oauth_callback': callback,
'oauth_nonce': oauth.generate_nonce(),
'oauth_consumer_key': self.key
}
self.consumer = oauth.OAuthConsumer(key=self.key, secret=self.secret)
if access_token_key is None:
req = oauth.OAuthRequest(http_method="GET",
http_url=TOKEN_REQUEST_URL,
parameters=params)
req.sign_request(oauth.OAuthSignatureMethod_HMAC_SHA1(),
self.consumer, None)
resp = urllib2.urlopen(req.to_url())
request_token = dict(urlparse.parse_qsl(resp.read()))
self.request_token = oauth.OAuthToken(
request_token['oauth_token'],
request_token['oauth_token_secret'])
self.access_token = None
else:
self.request_token = None
self.access_token = oauth.OAuthToken(access_token_key,
access_token_secret)
#iterate through courses and get their membership info via LTI
timestamp = oauth.generate_timestamp()
nonce = oauth.generate_nonce(16)
postParams = {}
postParams['lti_message_type'] = 'basic-lis-readmembershipsforcontext'
postParams['id'] = course.LTIid
postParams['lti_version'] = 'LTI-1p0'
postParams['oauth_consumer_key'] = 'LTI_ACJ'
postParams['oauth_callback'] = 'about:blank'
postParams['oauth_version'] = '1.0'
postParams['oauth_signature_method'] = 'HMAC-SHA1'
postParams['oauth_timestamp'] = timestamp
postParams['oauth_nonce'] = nonce
req = oauth.OAuthRequest(http_url=course.LTIURL,
http_method='POST',
parameters=postParams)
hmacAlg = hmac.HMAC(
'acjsecret&',
urls.url_quote_plus(req.get_normalized_http_method()) + '&' +
urls.url_quote_plus(course.LTIURL) + '&' +
urls.url_quote_plus(req.get_normalized_parameters()), hashlib.sha1)
postParams['oauth_signature'] = base64.b64encode(hmacAlg.digest())
xmlString = requests.post(course.LTIURL, data=postParams).text
root = ET.fromstring(xmlString)
#find the course in ACJ, create if it does not exist
tmpCourse = Course.query.filter_by(name=course.courseName).first()
if not tmpCourse:
newCourse = Course(course.courseName)
