def authorize(self):
if request.method == u"POST":
token = request.form.get("oauth_token")
return self.authorized(token)
else:
token = request.args.get(u"oauth_token", None)
if token is None:
return "oauth_token required", 400
req_token = RequestToken.query(
RequestToken.token == token).get()
if req_token is None:
# Joskus App Enginen datastore ei pysy OAuth-prosessin
# tahdissa mukana:
time.sleep(2)
req_token = RequestToken.query(
RequestToken.token == token).get()
if req_token is None:
return "request token not found", 503
client = req_token.client.get()
return render_template(
u"authorize.html",
token=token,
req_token=req_token,
client=client)
def start_authorizing(request, key):
"""Get the initial access token and send the user to authorize it"""
prosthetic = get_object_or_404(Prosthetic, id=key)
wrangler = prosthetic.wrangler()
try:
token = wrangler.get_request_token()
# Save the token ready for the callback
try:
token = RequestToken.objects.get(oauth_key=token.key)
logging.error("request token for key already exists!")
token.delete()
except RequestToken.DoesNotExist:
pass
request_token = RequestToken(oauth_key=token.key,
oauth_secret=token.secret,
prosthetic=prosthetic)
request_token.save()
callback_url = "http://%s/oauth_callback/" % settings.LOCAL_SERVER
start = wrangler.authorize_request_token_url(token, callback_url)
return redirect(start)
except urlfetch.DownloadError, e:
return render_error(request, "Can't connect to API server: %s" % (e))
def save_request_token(self, client_key, request_token, callback,
realm=None, secret=None):
client = Client.find_one({'client_key':client_key})
if client:
token = RequestToken(
request_token, callback, secret=secret, realm=realm)
token.client_id = client['_id']
RequestToken.insert(token)
def save_request_token(self, client_key, request_token, callback,
realm=None, secret=None):
client = Client.query(Client.client_key == client_key).get()
if client:
token = RequestToken(
token=request_token,
callback=callback,
secret=secret,
realm=realm,
client=client.key)
token.put()
def save_request_token(self,
client_key,
request_token,
callback,
realm=None,
secret=None):
token = RequestToken(request_token,
callback,
secret=secret,
realm=realm)
token.client = Client.query.filter_by(client_key=client_key).one()
db_session.add(token)
db_session.commit()
def validate_request_token(self, client_key, resource_owner_key):
token = None
if client_key:
client = Client.query(Client.client_key == client_key).get()
if client:
token = RequestToken.query(
RequestToken.token == resource_owner_key,
RequestToken.client == client.key).get()
else:
token = RequestToken.query(
RequestToken.token == resource_owner_key).get()
return token is not None
def validate_request_token(self, client_key, resource_owner_key):
token = None
if client_key:
client = Client.query(Client.client_key == client_key).get()
if client:
token = RequestToken.query(
RequestToken.token == resource_owner_key,
RequestToken.client == client.key).get()
else:
token = RequestToken.query(
RequestToken.token == resource_owner_key).get()
return token is not None
def save_request_token(self,
client_key,
request_token,
callback,
realm=None,
secret=None):
client = Client.query(Client.client_key == client_key).get()
if client:
token = RequestToken(token=request_token,
callback=callback,
secret=secret,
realm=realm,
client=client.key)
token.put()
def get_callback(self, request_token):
token = RequestToken.query(RequestToken.token == request_token).get()
if token:
return token.callback
else:
return None
def save_request_token(self,
client_key,
request_token,
callback,
realm=None,
secret=None):
client = Client.find_one({'client_key': client_key})
if client:
token = RequestToken(request_token,
callback,
secret=secret,
realm=realm)
token.client_id = client['_id']
RequestToken.insert(token)
def get(self):
request_token_key = self.request.get("oauth_token")
request_verifier = self.request.get('oauth_verifier')
if not request_token_key:
self.redirect('/')
return
request_token = RequestToken.gql("WHERE token_key=:1", request_token_key).get()
request_token.key.delete()
auth = tweepy.OAuthHandler(Const.CONSUMER_KEY, Const.CONSUMER_SECRET)
auth.set_request_token(request_token.token_key, request_token.token_secret)
access_token = auth.get_access_token(request_verifier)
cookie = get_cookie()
memcache.set(cookie['sid'].value, access_token, SESSION_EXPIRE) #@UndefinedVariable
twitter_user = get_twitter_data(cookie)
user = User.get_or_insert(User.create_key(twitter_user['id']),
userId=twitter_user['id'])
user.accessToken = access_token.key
user.accessSecret = access_token.secret
user.screenName=twitter_user['screen_name']
user.image=twitter_user['profile_image_url']
user.put()
self.redirect('/')
def get_callback(self, request_token):
token = RequestToken.query(RequestToken.token == request_token).get()
if token:
return token.callback
else:
return None
def save_access_token(self,
client_key,
access_token,
request_token,
realm=None,
secret=None):
client = Client.find_one({'client_key': client_key})
if client:
req_token = RequestToken.find_one({'token': request_token},
as_obj=True)
if req_token:
if not req_token['user_id']:
req_token['user_id'] = current_user.get_id()
req_token.save()
token = AccessToken.find_or_create(
client_id=client['_id'],
user_id=req_token['user_id'], #current_user.get_id(),
realm=realm if realm else req_token['realm'])
token.secret = secret
token.token = access_token
token.save()
def validate_request_token(self, client_key, resource_owner_key):
# TODO: make client_key optional
token = None
if client_key:
client = Client.find_one({'client_key':client_key})
if client:
token = RequestToken.find_one(
{'token':access_token, 'client_id': client['_id']})
else:
token = RequestToken.find_one(
{'token':resource_owner_key})
return token != None
def authorize(self):
if request.method == u"POST" or 'done' in request.args:
token = request.form.get("oauth_token")
if not token:
token = request.args.get("oauth_token")
return self.authorized(token, request = request)
else:
# TODO: Authenticate client
token_key = request.args.get(u"oauth_token")
token = RequestToken.find_one({'token': token_key})
if token:
realm = token.get('realm')
# TODO: Make this more robust.
session['realm'] = realm
if realm and realm in APIS:
#url = ("%s?first_oauth_token=%s" %
# (url_for('%s.finished' % realm, _external = True), token_key))
session['original_token'] = token_key
url = url_for('%s.finished' % realm, _external = True)
resp = APIS[realm].authorize(
callback = url, **APIS[realm].auth_params)
return resp
return render_template(u"authorize.html", token=token_key,
realm = token['realm'].title())
# If we got here, it's because we don't recognize the client attempting
# to connect. Send them an "unauthorized" error.
abort(403)
def get_callback(self, request_token):
token = RequestToken.find_one({'token': request_token})
if token:
return token.get('callback')
else:
return None
def get_callback(self, request_token):
token = RequestToken.find_one(
{'token':request_token})
if token:
return token.get('callback')
else:
return None
def validate_request_token(self, client_key, resource_owner_key):
# TODO: make client_key optional
token = None
if client_key:
client = Client.find_one({'client_key': client_key})
if client:
token = RequestToken.find_one({
'token': access_token,
'client_id': client['_id']
})
else:
token = RequestToken.find_one({'token': resource_owner_key})
return token != None
def get_realm(self, client_key, request_token):
client = Client.find_one({'client_key':client_key})
if client:
return RequestToken.find_one(
{'token':request_token, 'client_id': client['_id']})['realm']
else:
return None
def get_realm(self, client_key, request_token):
client = Client.find_one({'client_key': client_key})
if client:
return RequestToken.find_one({
'token': request_token,
'client_id': client['_id']
})['realm']
else:
return None
def validate_verifier(self, client_key, resource_owner_key, verifier):
token = None
client = Client.query(Client.client_key == client_key).get()
if client:
token = RequestToken.query(
RequestToken.client == client.key,
RequestToken.token == resource_owner_key,
RequestToken.verifier == verifier).get()
return token is not None
def get_realm(self, client_key, request_token):
client = Client.find_one({'client_key':client_key})
if client:
token = RequestToken.find_one(
{'token':request_token, 'client_id': client['_id']})
if token:
return token.get('realm')
return None
def validate_verifier(self, client_key, resource_owner_key, verifier):
token = None
client = Client.find_one({'client_key':client_key})
if client:
token = RequestToken.find_one(
{'token':resource_owner_key,
'client_id': client['_id'],
'verifier':verifier})
return token != None
def save_request_token(self, client_key, request_token, callback,
realm=None, secret=None):
client = Client.find_one({'client_key':client_key})
if client:
token = RequestToken.find_or_create(realm = realm,
user_id = current_user.get_id(), client_id = client['_id'])
token.token = request_token
token.callback = callback
token.secret = secret
token.save()
def validate_verifier(self, client_key, resource_owner_key, verifier):
token = None
client = Client.query(Client.client_key == client_key).get()
if client:
token = RequestToken.query(
RequestToken.client == client.key,
RequestToken.token == resource_owner_key,
RequestToken.verifier == verifier).get()
return token is not None
def validate_verifier(self, client_key, resource_owner_key, verifier):
token = None
client = Client.find_one({'client_key': client_key})
if client:
token = RequestToken.find_one({
'token': resource_owner_key,
'client_id': client['_id'],
'verifier': verifier
})
return token != None
def get_realm(self, client_key, request_token):
client = Client.query(Client.client_key == client_key).get()
if client:
token = RequestToken.query(
RequestToken.token == request_token,
RequestToken.client == client.key).get()
if token:
return token.realm
return None
def get_request_token_secret(self, client_key, resource_owner_key):
client = Client.query(Client.client_key == client_key).get()
if client:
token = RequestToken.query(
RequestToken.client == client.key,
RequestToken.token == resource_owner_key).get()
if token:
return token.secret
return None
def validate_timestamp_and_nonce(self, client_key, timestamp, nonce,
request_token=None, access_token=None):
token = True
req_token = True
client = Client.find_one({'client_key':client_key})
if client:
nonce = Nonce.find_one({'nonce':nonce, 'timestamp':timestamp,
'client_id':client['_id']})
if nonce:
if request_token:
req_token = RequestToken.find_one(
{'_id':nonce['request_token_id'], 'token':request_token})
if access_token:
token = RequestToken.find_one(
{'_id':nonce['request_token_id'], 'token':access_token})
return token and req_token and nonce != None
def get_realm(self, client_key, request_token):
client = Client.query(Client.client_key == client_key).get()
if client:
token = RequestToken.query(
RequestToken.token == request_token,
RequestToken.client == client.key).get()
if token:
return token.realm
return None
def get_request_token_secret(self, client_key, resource_owner_key):
client = Client.find_one({'client_key':client_key})
if client:
token = RequestToken.find_one(
{'token':resource_owner_key,
'client_id': client['_id']})
if token:
return token['secret']
return None
def get_request_token_secret(self, client_key, resource_owner_key):
client = Client.query(Client.client_key == client_key).get()
if client:
token = RequestToken.query(
RequestToken.client == client.key,
RequestToken.token == resource_owner_key).get()
if token:
return token.secret
return None
def get_request_token_secret(self, client_key, resource_owner_key):
client = Client.find_one({'client_key': client_key})
if client:
token = RequestToken.find_one({
'token': resource_owner_key,
'client_id': client['_id']
})
if token:
return token['secret']
return None
def get_realm(self, client_key, request_token):
client = Client.find_one({'client_key': client_key})
if client:
token = RequestToken.find_one({
'token': request_token,
'client_id': client['_id']
})
if token:
return token.get('realm')
return None
def save_request_token(token, req):
assert isinstance(req, oauthlib.common.Request)
rt = token['oauth_token']
rts = token['oauth_token_secret']
client = req.client
assert type(client) is Client, type(client)
assert isinstance(req.redirect_uri, str) # py3
t = RequestToken(client=req.client,
token=rt,
secret=rts,
redirect_uri=req.redirect_uri,
realms=client.default_realms) # ??
request_tokens.append(t)
def save_access_token(self, client_key, access_token, request_token,
secret=None):
client = Client.query(Client.client_key == client_key).get()
req_token = RequestToken.query(
RequestToken.token == request_token).get()
if client and req_token:
token = AccessToken(
token=access_token,
secret=secret,
client=client.key,
resource_owner=req_token.resource_owner,
realm=req_token.realm)
token.put()
def save_access_token(self, client_key, access_token, request_token,
realm=None, secret=None):
client = Client.find_one({'client_key':client_key})
if client:
token = AccessToken(access_token, secret=secret, realm=realm)
token.client_id = client['_id']
req_token = RequestToken.find_one({'token':request_token})
if req_token:
token['resource_owner_id'] = req_token['resource_owner_id']
token['realm'] = req_token['realm']
AccessToken.insert(token)
def start_authorizing(request, key):
"""Get the initial access token and send the user to authorize it"""
prosthetic = get_object_or_404(Prosthetic, id=key)
wrangler = prosthetic.wrangler()
try:
token = wrangler.get_request_token()
# Save the token ready for the callback
try:
token = RequestToken.objects.get(oauth_key=token.key)
logging.error("request token for key already exists!")
token.delete()
except RequestToken.DoesNotExist:
pass
request_token = RequestToken(oauth_key=token.key, oauth_secret=token.secret, prosthetic=prosthetic)
request_token.save()
callback_url = "http://%s/oauth_callback/" % settings.LOCAL_SERVER
start = wrangler.authorize_request_token_url(token, callback_url)
return redirect(start)
except urlfetch.DownloadError, e:
return render_error(request, "Can't connect to API server: %s" % (e))
def authorize(self):
if request.method == u"POST":
token = request.form.get("oauth_token")
return self.authorized(token)
else:
token = request.args.get(u"oauth_token", None)
if token is None:
return "oauth_token required", 400
req_token = RequestToken.query(RequestToken.token == token).get()
if req_token is None:
# Joskus App Enginen datastore ei pysy OAuth-prosessin
# tahdissa mukana:
time.sleep(2)
req_token = RequestToken.query(
RequestToken.token == token).get()
if req_token is None:
return "request token not found", 503
client = req_token.client.get()
return render_template(u"authorize.html",
token=token,
req_token=req_token,
client=client)
def validate_timestamp_and_nonce(self,
client_key,
timestamp,
nonce,
request_token=None,
access_token=None):
token = True
req_token = True
client = Client.find_one({'client_key': client_key})
if client:
nonce = Nonce.find_one({
'nonce': nonce,
'timestamp': timestamp,
'client_id': client['_id']
})
if nonce:
if request_token:
req_token = RequestToken.find_one({
'_id':
nonce['request_token_id'],
'token':
request_token
})
if access_token:
token = RequestToken.find_one({
'_id':
nonce['request_token_id'],
'token':
access_token
})
return token and req_token and nonce != None
def save_request_token(self,
client_key,
request_token,
callback,
realm=None,
secret=None):
client = Client.find_one({'client_key': client_key})
if client:
token = RequestToken.find_or_create(realm=realm,
user_id=current_user.get_id(),
client_id=client['_id'])
token.token = request_token
token.callback = callback
token.secret = secret
token.save()
def save_access_token(self,
client_key,
access_token,
request_token,
secret=None):
client = Client.query(Client.client_key == client_key).get()
req_token = RequestToken.query(
RequestToken.token == request_token).get()
if client and req_token:
token = AccessToken(token=access_token,
secret=secret,
client=client.key,
resource_owner=req_token.resource_owner,
realm=req_token.realm)
token.put()
def save_timestamp_and_nonce(self, client_key, timestamp, nonce,
request_token=None, access_token=None):
client = Client.find_one({'client_key':client_key})
if client:
nonce = Nonce(nonce, timestamp)
nonce.client_id = client['_id']
if request_token:
req_token = RequestToken.find_one({'token':request_token})
nonce.request_token_id = req_token['_id']
if access_token:
token = AccessToken.find_one({'token':access_token})
nonce.access_token_id = token['_id']
nonce.insert()
def save_access_token(self,
client_key,
access_token,
request_token,
realm=None,
secret=None):
client = Client.find_one({'client_key': client_key})
if client:
token = AccessToken(access_token, secret=secret, realm=realm)
token.client_id = client['_id']
req_token = RequestToken.find_one({'token': request_token})
if req_token:
token['resource_owner_id'] = req_token['resource_owner_id']
token['realm'] = req_token['realm']
AccessToken.insert(token)
def save_timestamp_and_nonce(self, client_key, timestamp, nonce,
request_token=None, access_token=None):
client = Client.query(Client.client_key == client_key).get()
if client:
nonce = Nonce(
nonce=nonce,
timestamp=timestamp,
client=client.key)
if request_token:
req_token = RequestToken.query(
RequestToken.token == request_token).get()
nonce.request_token = req_token.key
if access_token:
token = AccessToken.query(
AccessToken.token == access_token).get()
nonce.access_token = token.key
nonce.put()
def save_timestamp_and_nonce(self,
client_key,
timestamp,
nonce,
request_token=None,
access_token=None):
client = Client.query(Client.client_key == client_key).get()
if client:
nonce = Nonce(nonce=nonce, timestamp=timestamp, client=client.key)
if request_token:
req_token = RequestToken.query(
RequestToken.token == request_token).get()
nonce.request_token = req_token.key
if access_token:
token = AccessToken.query(
AccessToken.token == access_token).get()
nonce.access_token = token.key
nonce.put()
def save_timestamp_and_nonce(self,
client_key,
timestamp,
nonce,
request_token=None,
access_token=None):
client = Client.find_one({'client_key': client_key})
if client:
nonce = Nonce(nonce, timestamp)
nonce.client_id = client['_id']
if request_token:
req_token = RequestToken.find_one({'token': request_token})
nonce.request_token_id = req_token['_id']
if access_token:
token = AccessToken.find_one({'token': access_token})
nonce.access_token_id = token['_id']
nonce.insert()
def save_access_token(self, client_key, access_token, request_token,
realm=None, secret=None):
client = Client.find_one({'client_key':client_key})
if client:
req_token = RequestToken.find_one(
{'token':request_token}, as_obj = True)
if req_token:
if not req_token['user_id']:
req_token['user_id'] = current_user.get_id()
req_token.save()
token = AccessToken.find_or_create(
client_id = client['_id'],
user_id = req_token['user_id'],#current_user.get_id(),
realm = realm if realm else req_token['realm'])
token.secret = secret
token.token = access_token
token.save()
def setUp(self):
self.user = User(username='******', password='******')
self.client = Client(user=self.user,
redirect_uris=[REDIRECT_URI],
realms=['read'],
client_key=CONSUMER_KEY,
client_secret=CONSUMER_SECRET)
self.request_token = RequestToken(client=self.client,
token=REQUEST_TOKEN,
secret=REQUEST_TOKEN_SECRET,
redirect_uri=REDIRECT_URI,
realms=['read'],
user=self.user)
self.access_token = AccessToken(client=self.client,
user=self.user,
realms=[REDIRECT_URI],
token=ACCESS_TOKEN,
secret=ACCESS_TOKEN_SECRET)
self.nonce = Nonce(client_key=self.client.client_key,
timestamp=TIMESTAMP,
nonce=NONCE,
request_token=REQUEST_TOKEN,
access_token=ACCESS_TOKEN)
def authorize(self):
if request.method == u"POST" or 'done' in request.args:
token = request.form.get("oauth_token")
if not token:
token = request.args.get("oauth_token")
return self.authorized(token, request=request)
else:
# TODO: Authenticate client
token_key = request.args.get(u"oauth_token")
token = RequestToken.find_one({'token': token_key})
if token:
realm = token.get('realm')
# TODO: Make this more robust.
session['realm'] = realm
if realm and realm in APIS:
#url = ("%s?first_oauth_token=%s" %
# (url_for('%s.finished' % realm, _external = True), token_key))
session['original_token'] = token_key
url = url_for('%s.finished' % realm, _external=True)
resp = APIS[realm].authorize(callback=url,
**APIS[realm].auth_params)
return resp
return render_template(u"authorize.html",
token=token_key,
realm=token['realm'].title())
# If we got here, it's because we don't recognize the client attempting
# to connect. Send them an "unauthorized" error.
abort(403)
def get_callback(self, request_token):
return RequestToken.find_one({'token': request_token})['callback']
def get(self):
auth = tweepy.OAuthHandler(Const.CONSUMER_KEY, Const.CONSUMER_SECRET)
auth_url = auth.get_authorization_url()
request_token = RequestToken(token_key=auth.request_token.key, token_secret=auth.request_token.secret)
request_token.put()
self.redirect(auth_url)
def save_verifier(self, request_token, verifier):
token = RequestToken.query(RequestToken.token == request_token).get()
token.verifier = verifier
token.resource_owner = g.user.key
token.put()
def save_verifier(self, request_token, verifier):
token = RequestToken.find_one({'token':request_token})
token['verifier'] = verifier
token['resource_owner_id'] = g.user['_id']
RequestToken.get_collection().save(token)
def save_verifier(self, request_token, verifier):
token = RequestToken.find_one({'token':request_token})
token['verifier'] = verifier
token['user_id'] = current_user.get_id()
RequestToken.get_collection().save(token)
def save_request_token(self, client_key, request_token, callback,
realm=None, secret=None):
token = RequestToken(request_token, callback, secret=secret, realm=realm)
token.client = Client.query.filter_by(client_key=client_key).one()
db_session.add(token)
db_session.commit()
def save_verifier(self, request_token, verifier):
token = RequestToken.query(
RequestToken.token == request_token).get()
token.verifier = verifier
token.resource_owner = g.user.key
token.put()
def save_verifier(self, request_token, verifier):
token = RequestToken.find_one({'token': request_token})
token['verifier'] = verifier
token['user_id'] = current_user.get_id()
RequestToken.get_collection().save(token)
def save_verifier(self, request_token, verifier):
token = RequestToken.find_one({'token': request_token})
token['verifier'] = verifier
token['resource_owner_id'] = g.user['_id']
RequestToken.get_collection().save(token)
def get_callback(self, request_token):
return RequestToken.find_one(
{'token':request_token})['callback']
