def oauth_return(request):
if 'request_token' not in request.session:
return redirect('dash.views.oauth_login')
req_token = oauth.OAuthToken.from_string(request.session['request_token'])
if req_token.key != request.GET.get('oauth_token', 'no-token'):
del request.session['request_token']
return redirect('dash.views.oauth_login')
twitter = OAuthApi(CONSUMER_KEY, CONSUMER_SECRET, req_token)
acc_token = twitter.getAccessToken()
request.session['access_token'] = acc_token.to_string()
auth_user = authenticate(access_token=acc_token)
if auth_user:
login(request, auth_user)
else:
del request.session['access_token']
del request.session['request_token']
return HttpResponse("Unable to authenticate you!")
print "User: %s" % auth_user
print "request.user: %s" % request.user
print "is_auth: %s" % request.user.is_authenticated()
return redirect('dash.views.home')
def generate(self):
# get the bitly information
self.getValueFromUser('BITLY_USER', "bit.ly username: "******"api key from 'http://bit.ly/a/account': ")
# get the twitter information
from oauthtwitter import OAuthApi
twitter = OAuthApi(self.__APP_KEY, self.__APP_SECRET)
temp_creds = twitter.getRequestToken()
print "visit '%s' and write the pin:" \
% twitter.getAuthorizationURL(temp_creds)
oauth_verifier = sys.stdin.readline().strip()
access_token = twitter.getAccessToken(temp_creds, oauth_verifier)
config['TWIT_TOKEN'] = access_token['oauth_token']
config['TWIT_SECRET'] = access_token['oauth_token_secret']
# get the svn information
self.getValueFromUser('SVN_FS_ROOT', "Root directory for svn: ",
'/svn/')
self.getValueFromUser('SVN_TRAC_FORMAT',
"Format for trac svn urls: ",
"http://trac.edgewall.org/changeset/%d")
# write out the configuration
handle = open(filename, 'w')
keys = self.__config__.keys()
keys.sort()
for key in keys:
handle.write("%s='%s'\n" % (key, config[key]))
handle.write("def normalizeUser(user):\n")
handle.write(" return user\n")
pphandle.close()
def finalize_handshake( self, request ): twitter = OAuthApi( TWITTER_KEY, TWITTER_SECRET, request.session[ 'request_token' ] ) request.session[ 'access_token' ] = twitter.getAccessToken() twitter = OAuthApi( TWITTER_KEY, TWITTER_SECRET, request.session[ 'access_token' ] ) user_info = twitter.GetUserInfo() request.session[ 'twitter_info' ] = user_info return request
def _do_finish(request):
# TODO: refactor this out -- should be in a util class or on the model
# TODO: add check for this, redirect if not found
try:
request_token = request.session['twitter_request_token']
oauth = OAuthApi(settings.TWITTER['CONSUMER_KEY'], settings.TWITTER['CONSUMER_SECRET'], request_token)
access_token = oauth.getAccessToken()
twitter = OAuthApi(settings.TWITTER['CONSUMER_KEY'], settings.TWITTER['CONSUMER_SECRET'], access_token)
user_info = twitter.GetUserInfo()
default_account = AuthorizedAccount.objects.default_account()
s = Seeder(
twitter_id = user_info.id,
twitter_username = user_info.screen_name,
authorized_for = default_account
)
s.set_expires_on_in_days(request.session['duration'])
s.save()
Token.objects.create(
seeder = s,
oauth_token = access_token.key,
oauth_token_secret = access_token.secret
)
except HTTPError:
pass
def get_profile_from_callback(self, request):
"""Extract the access token and profile details from OAuth callback"""
request_token = request.session.get('twitter_request_token', None)
if not request_token: return None
token = oauth.OAuthToken.from_string(request_token)
if token.key != request.GET.get('oauth_token', 'no-token'):
return HttpResponse(status=400)
twitter = OAuthApi(self.consumer_key, self.consumer_secret, token)
access_token = twitter.getAccessToken()
twitter = oauthtwitter.OAuthApi(self.consumer_key,
self.consumer_secret, access_token)
try:
profile = twitter.GetUserInfo()
except:
return None
return {
'access_token': access_token.to_string(),
'id': profile.id,
'username': profile.screen_name,
'fullname': profile.name,
'email': '',
}
def callback(request):
req_token = oauth.Token.from_string(request.session.get('request_token'))
api = OAuthApi(settings.CONSUMER_KEY, settings.CONSUMER_SECRET, req_token.key, req_token.secret)
access_token = api.getAccessToken()
request.session["access_token"] = access_token.to_string()
del request.session["request_token"]
return HttpResponseRedirect(get_root_path() + "/")
def get_access_token(window):
auth_api = OAuthApi(CONSUMER_KEY, CONSUMER_SECRET)
request_token = auth_api.getRequestToken()
authorization_url = auth_api.getAuthorizationURL(request_token)
webbrowser.open(authorization_url)
auth_api = OAuthApi(CONSUMER_KEY, CONSUMER_SECRET, request_token)
dialog = gtk.Dialog("Enter PIN", window, gtk.DIALOG_MODAL, (gtk.STOCK_OK, gtk.RESPONSE_OK, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL))
entry = gtk.Entry()
dialog.vbox.pack_start(entry)
entry.show()
response = dialog.run()
dialog.hide()
if response == gtk.RESPONSE_OK:
pin = entry.get_text()
try:
access_token = auth_api.getAccessToken(pin)
except HTTPError:
access_token = None
return access_token
else:
return None
def Callback(request):
"""docstring for Callback"""
verifier=request.GET.get('oauth_verifier',None)
request_token=request.session['request_token']
twitter=OAuthApi(CONSUMER_KEY,CONSUMER_SECRET,request_token)
# twitter=OAuthApi(CONSUMER_KEY,CONSUMER_SECRET)
# access_token=twitter.getAccessToken(request_token,verifier)
access_token=twitter.getAccessToken()
# api=t.Api(CONSUMER_KEY,CONSUMER_SECRET,access_token['oauth_token'],access_token['oauth_token_secret'])
twitter=OAuthApi(CONSUMER_KEY,CONSUMER_SECRET,access_token)
# user=api.GetUserInfo()
user=twitter.GetUserInfo()
twitter_auth=UserMeta(user=request.user,key="oauth",value=1)
twitter_auth.save()
# twitter_access_token_key=UserMeta(user=request.user,key="access_token_key",value=access_token['oauth_token'])
# twitter_access_token_key.save()
# twitter_access_token_secret=UserMeta(user=request.user,key="access_token_secret",value=access_token['oauth_token_secret'])
# twitter_access_token_secret.save()
twitter_access_token_string=UserMeta(user=request.user,key="twitter_access_token_string",value=access_token.to_string())
twitter_access_token_string.save()
twitter_id=UserMeta(user=request.user,key="twitter_id",value=user.id)
twitter_id.save()
twitter_name=UserMeta(user=request.user,key="twitter_name",value=user.name)
twitter_name.save()
twitter_screen_name=UserMeta(user=request.user,key="twitter_screen_name",value=user.screen_name)
twitter_screen_name.save()
twitter_description=UserMeta(user=request.user,key="twitter_description",value=user.description)
twitter_description.save()
twitter_profile_image_url=UserMeta(user=request.user,key="twitter_profile_image_url",value=user.profile_image_url)
twitter_profile_image_url.save()
return HttpResponseRedirect("/setting")
def get(self):
# get req token from DB
token = self.request.get("oauth_token")
req_token = fetcher.get_req_token_by_oauth_token(token)
if not req_token:
self.redirect('/oauth/twitter/signin')
return
# model to object
req_token_obj = oauth.OAuthToken(req_token.token, req_token.secret)
return_url = req_token.return_url
# get access token
twit = OAuthApi(access_token=req_token_obj)
try:
access_token = twit.getAccessToken()
except DownloadError:
self.redirect_error(msg="twitter is over capacity")
return
token = access_token.key
secret = access_token.secret
# delete OAuthToken
fetcher.delete_req_token_by_model(req_token)
# get user info
try:
twit = OAuthApi(access_token=access_token)
user = twit.GetUserInfo()
except DownloadError:
self.redirect_error(msg="twitter is over capacity")
return
# add user
user_model = fetcher.set_user(twit_id=str(user.id),
twit_name=user.name,
twit_screen_name=user.screen_name,
twit_img_url=user.profile_image_url)
# add session
self.new_session(user_model, token, secret)
# redirect to home
if not return_url:
return_url = '/'
self.redirect(return_url)
def get_user_tokens(app_key, app_secret_key):
if not os.path.isfile("../terminitter.oauth"): # no user tokens found, create some
twitter = OAuthApi(app_key, app_secret_key)
temp_credentials = twitter.getRequestToken()
print(twitter.getAuthorizationURL(temp_credentials))
oauth_verifier = raw_input("Go the the URL above, and paste the PIN here: ")
tokens = twitter.getAccessToken(temp_credentials, oauth_verifier)
oauthf = open("../terminitter.oauth", "w")
oauthf.write(tokens["oauth_token"] + "\n" + tokens["oauth_token_secret"])
oauthf.close()
return [access_token["oauth_token"], access_token["oauth_token_secret"]]
else: # read user tokens from file
oauthf = open("../terminitter.oauth", "r")
oauth_tokens = oauthf.read().splitlines()
return [oauth_tokens[0], oauth_tokens[1]]
def twitter_return(request):
request_token = request.session.get('request_token', None)
# If there is no request_token for session,
# means we didn't redirect user to twitter
if not request_token:
# Redirect the user to the login page,
# So the user can click on the sign-in with twitter button
return HttpResponse("We didn't redirect you to twitter...")
token = oauth.OAuthToken.from_string(request_token)
# If the token from session and token from twitter does not match
# means something bad happened to tokens
if token.key != request.GET.get('oauth_token', 'no-token'):
del request.session['request_token']
# Redirect the user to the login page
return HttpResponse("Something wrong! Tokens do not match...")
twitter = OAuthApi(CONSUMER_KEY, CONSUMER_SECRET, token)
try:
fr = twitter.GetFriendsTimeline()
except HTTPError as e:
return HttpResponse(str(e))
access_token = twitter.getAccessToken()
request.session['access_token'] = access_token.to_string()
auth_user = authenticate(access_token=access_token)
# if user is authenticated then login user
if auth_user:
login(request, auth_user)
else:
# We were not able to authenticate user
# Redirect to login page
del request.session['access_token']
del request.session['request_token']
return HttpResponse("Unable to authenticate you!")
# authentication was successful, use is now logged in
# foo = twitter.GetFollowers()
# return HttpResponse("You are logged in %s" % twitter.GetFriends())
# return HttpResponse("You are logged in" + len(foo))
import string
return HttpResponse("You are logged in %s" % twitter.GetPublicTimeline())
def Callback(request):
"""docstring for Callback"""
verifier = request.GET.get('oauth_verifier', None)
request_token = request.session['request_token']
twitter = OAuthApi(CONSUMER_KEY, CONSUMER_SECRET, request_token)
# twitter=OAuthApi(CONSUMER_KEY,CONSUMER_SECRET)
# access_token=twitter.getAccessToken(request_token,verifier)
access_token = twitter.getAccessToken()
# api=t.Api(CONSUMER_KEY,CONSUMER_SECRET,access_token['oauth_token'],access_token['oauth_token_secret'])
twitter = OAuthApi(CONSUMER_KEY, CONSUMER_SECRET, access_token)
# user=api.GetUserInfo()
user = twitter.GetUserInfo()
twitter_auth = UserMeta(user=request.user, key="oauth", value=1)
twitter_auth.save()
# twitter_access_token_key=UserMeta(user=request.user,key="access_token_key",value=access_token['oauth_token'])
# twitter_access_token_key.save()
# twitter_access_token_secret=UserMeta(user=request.user,key="access_token_secret",value=access_token['oauth_token_secret'])
# twitter_access_token_secret.save()
twitter_access_token_string = UserMeta(user=request.user,
key="twitter_access_token_string",
value=access_token.to_string())
twitter_access_token_string.save()
twitter_id = UserMeta(user=request.user, key="twitter_id", value=user.id)
twitter_id.save()
twitter_name = UserMeta(user=request.user,
key="twitter_name",
value=user.name)
twitter_name.save()
twitter_screen_name = UserMeta(user=request.user,
key="twitter_screen_name",
value=user.screen_name)
twitter_screen_name.save()
twitter_description = UserMeta(user=request.user,
key="twitter_description",
value=user.description)
twitter_description.save()
twitter_profile_image_url = UserMeta(user=request.user,
key="twitter_profile_image_url",
value=user.profile_image_url)
twitter_profile_image_url.save()
return HttpResponseRedirect("/setting")
class OauthAccess():
CONSUMER_KEY = "UsGVAZvCxNiZsO7eKkSZzA"
CONSUMER_SECRET = "M3lOLh3w9tsgEPG423EhPSkHobGHfinXR2Ju4lxkc"
ACCESS_TOKEN_URL = 'https://twitter.com/oauth/access_token'
mPin = ""
mOauthRequestToken = ""
mOauthAccessToken = ""
mUser = twitter.User
mTwitterApi = ""
def __init__(self, pOauthRequestToken, pPin):
self.mOauthRequestToken = pOauthRequestToken
self.mPin = pPin
def getOauthAccess(self):
self.mTwitterApi = OAuthApi(self.CONSUMER_KEY, self.CONSUMER_SECRET, self.mOauthRequestToken)
self.mOauthAccessToken = self.mTwitterApi.getAccessToken(self.mPin)
self.mAuthenticatedTwitterInstance = OAuthApi(self.CONSUMER_KEY, self.CONSUMER_SECRET, self.mOauthAccessToken)
self.mUser = self.mAuthenticatedTwitterInstance.GetUserInfo()
class OauthAccess():
CONSUMER_KEY = "atG3B3lZ6fOKshfiUr5FAMDER"
CONSUMER_SECRET = "zJ52dNaHe3CHDHZahmBC7JwciUS93rFhf5pPzk79CqKZN37R1z"
ACCESS_TOKEN_URL = 'https://twitter.com/oauth/access_token'
mPin = ""
mOauthRequestToken = ""
mOauthAccessToken = ""
mUser = twitter.User
mTwitterApi = ""
def __init__(self, pOauthRequestToken, pPin):
self.mOauthRequestToken = pOauthRequestToken
self.mPin = pPin
def getOauthAccess(self):
self.mTwitterApi = OAuthApi(self.CONSUMER_KEY, self.CONSUMER_SECRET, self.mOauthRequestToken)
self.mOauthAccessToken = self.mTwitterApi.getAccessToken(self.mPin)
self.mAuthenticatedTwitterInstance = OAuthApi(self.CONSUMER_KEY, self.CONSUMER_SECRET, self.mOauthAccessToken)
self.mUser = self.mAuthenticatedTwitterInstance.GetUserInfo()
class OauthAccess():
CONSUMER_KEY = settings.TWITTER_CONSUMER_KEY
CONSUMER_SECRET = settings.TWITTER_CONSUMER_SECRET
ACCESS_TOKEN_URL = settings.TWITTER_ACCESS_TOKEN_URL
mPin = ""
mOauthRequestToken = ""
mOauthAccessToken = ""
mUser = twitter.User
mTwitterApi = ""
def __init__(self, pOauthRequestToken, pPin):
self.mOauthRequestToken = pOauthRequestToken
self.mPin = pPin
def getOauthAccess(self):
self.mTwitterApi = OAuthApi(self.CONSUMER_KEY, self.CONSUMER_SECRET, self.mOauthRequestToken)
self.mOauthAccessToken = self.mTwitterApi.getAccessToken(self.mPin)
self.mAuthenticatedTwitterInstance = OAuthApi(self.CONSUMER_KEY, self.CONSUMER_SECRET, self.mOauthAccessToken)
self.mUser = self.mAuthenticatedTwitterInstance.GetUserInfo()
def setup(self):
os.system('clear')
twitter = OAuthApi(self.consumer_key, self.consumer_secret)
# Get the temporary credentials for our next few calls
temp_credentials = twitter.getRequestToken()
# User pastes this into their browser to bring back a pin number
print(twitter.getAuthorizationURL(temp_credentials))
# Get the pin # from the user and get our permanent credentials
oauth_verifier = raw_input('What is the PIN? ')
access_token = twitter.getAccessToken(temp_credentials, oauth_verifier)
self.token = access_token['oauth_token']
self.secret = access_token['oauth_token_secret']
self.latest = 1
self.mention = 1
print 'Clitwi was successfully set up.'
def twitter_return(request):
request_token = request.session.get('request_token', None)
# If there is no request_token for session,
# means we didn't redirect user to twitter
if not request_token:
# Redirect the user to the login page,
# So the user can click on the sign-in with twitter button
return HttpResponse("We didn't redirect you to twitter...")
token = oauth.OAuthToken.from_string(request_token)
# If the token from session and token from twitter does not match
# means something bad happened to tokens
if token.key != request.GET.get('oauth_token', 'no-token'):
del request.session['request_token']
# Redirect the user to the login page
return HttpResponse("Something wrong! Tokens do not match...")
twitter = OAuthApi(CONSUMER_KEY, CONSUMER_SECRET, token)
access_token = twitter.getAccessToken()
request.session['access_token'] = access_token.to_string()
auth_user = authenticate(access_token=access_token)
# if user is authenticated then login user
if auth_user:
login(request, auth_user)
else:
# We were not able to authenticate user
# Redirect to login page
del request.session['access_token']
del request.session['request_token']
return HttpResponse("Unable to authenticate you!")
# authentication was successful, use is now logged in
return HttpResponse("You are logged in")
def twitter_return(request):
request_token = request.session.get('request_token', None)
# If there is no request_token for session,
# means we didn't redirect user to twitter
if not request_token:
# Redirect the user to the login page,
# So the user can click on the sign-in with twitter button
return HttpResponseRedirect('/login')
token = oauth.OAuthToken.from_string(request_token)
# If the token from session and token from twitter does not match
# means something bad happened to tokens
if token.key != request.GET.get('oauth_token', 'no-token'):
del request.session['request_token']
# Redirect the user to the login page
return HttpResponse("Something wrong! Tokens do not match...", status=500)
twitter = OAuthApi(CONSUMER_KEY, CONSUMER_SECRET, token)
access_token = twitter.getAccessToken()
request.session['access_token'] = access_token.to_string()
auth_user = authenticate(access_token=access_token)
# if user is authenticated then login user
if auth_user:
login(request, auth_user)
else:
# We were not able to authenticate user
# Redirect to login page
del request.session['access_token']
del request.session['request_token']
return HttpResponse("Unable to authenticate you!")
# authentication was successful, use is now logged in
return HttpResponse("You are logged in")
def auth():
authToken = None
authSecret = None
if os.path.exists('/tmp/twitter.tmp'):
f = open('/tmp/twitter.tmp', 'r')
authToken = f.readline().strip()
authSecret = f.readline().strip()
print "oauth_token: " + authToken
print "oauth_token_secret: " + authSecret
f.close()
needAuth = True
if authToken!=None and authSecret!=None:
twitter = OAuthApi(consumerKey, consumerSecret, authToken, authSecret)
if twitter.autorized():
needAuth = False
if needAuth:
twitter = OAuthApi(consumerKey, consumerSecret)
temp_credentials = twitter.getRequestToken()
print temp_credentials
print twitter.getAuthorizationURL(temp_credentials)
oauth_verifier = raw_input('What is the PIN? ')
access_token = twitter.getAccessToken(temp_credentials, oauth_verifier)
print access_token
print("oauth_token: " + access_token['oauth_token'])
print("oauth_token_secret: " + access_token['oauth_token_secret'])
f = open('/tmp/twitter.tmp', 'w')
f.write('%s\n%s'%(access_token['oauth_token'], access_token['oauth_token_secret']))
f.close()
twitter = OAuthApi(consumerKey, consumerSecret, access_token['oauth_token'], access_token['oauth_token_secret'])
return twitter
def obtainAuth(self):
twitter = OAuthApi(self.OAuthConsumerKey, self.OAuthConsumerSecret)
# Get the temporary credentials for our next few calls
temp_credentials = twitter.getRequestToken()
# User pastes this into their browser to bring back a pin number
print(twitter.getAuthorizationURL(temp_credentials))
# Get the pin # from the user and get our permanent credentials
oauth_verifier = raw_input('What is the PIN? ')
access_token = twitter.getAccessToken(temp_credentials, oauth_verifier)
self.OAuthUserToken = access_token['oauth_token']
self.OAuthUserTokenSecret = access_token['oauth_token_secret']
print("\n===========================")
print("To prevent this authorization process next session, " +
"add the following lines to the [twitter] section of " +
"your .trackupdaterc:")
print("OAuthUserToken: " + self.OAuthUserToken)
print("OAuthUserTokenSecret: " + self.OAuthUserTokenSecret)
print("===========================\n")
import iemdb
MESOSITE = iemdb.connect('mesosite', bypass=True)
mcursor = MESOSITE.cursor()
twitter = OAuthApi(config.get('twitter','consumerkey'),
config.get('twitter', 'consumersecret'))
# Get the temporary credentials for our next few calls
temp_credentials = twitter.getRequestToken()
# User pastes this into their browser to bring back a pin number
print(twitter.getAuthorizationURL(temp_credentials))
# Get the pin # from the user and get our permanent credentials
oauth_verifier = raw_input('What is the PIN? ')
access_token = twitter.getAccessToken(temp_credentials, oauth_verifier)
print("oauth_token: " + access_token['oauth_token'])
print("oauth_token_secret: " + access_token['oauth_token_secret'])
botuser = raw_input("What is username?")
mcursor.execute("DELETE from oauth_tokens where username = '******'" % (botuser,))
mcursor.execute("INSERT into oauth_tokens values ('%s','%s','%s')" % (botuser, access_token['oauth_token'], access_token['oauth_token_secret']) )
mcursor.close()
MESOSITE.commit()
# Do a test API call using our new credentials
twitter = OAuthApi(config.get('twitter', 'consumerkey'),
from oauth import oauth
from oauthtwitter import OAuthApi
import pprint
consumer_key = "" # TODO put your consumer_key
consumer_secret = "" # TODO put your consumer_secret
twitter = OAuthApi(consumer_key, consumer_secret)
# Get the temporary credentials for our next few calls
temp_credentials = twitter.getRequestToken()
# User pastes this into their browser to bring back a pin number
print(twitter.getAuthorizationURL(temp_credentials))
# Get the pin # from the user and get our permanent credentials
oauth_verifier = raw_input('What is the PIN? ')
access_token = twitter.getAccessToken(temp_credentials, oauth_verifier)
print("oauth_token: " + access_token['oauth_token'])
print("oauth_token_secret: " + access_token['oauth_token_secret'])
def get(self, action):
# Depending on the action requested /admin/<action>/
if action == 'register':
# Register a Twitter user with the application using
# OAuth. Works with the Option model to store the request and
# access tokens.
# Remove all the previous tokens matching oauth-* from the datastore.
options = Option.all()
options.filter('name >=', 'oauth-').filter('name <',
'oauth-' + u'\ufffd')
options.fetch(1000)
for option in options:
option.delete()
# Request an OAuth token and show the authorization URL on Twitter.
twitter = OAuthApi(consumer_key, consumer_secret)
credentials = twitter.getRequestToken()
url = twitter.getAuthorizationURL(credentials)
rendertext(self, '<a href="%s">%s</a><br />' % (url, url))
rendertext(
self,
'<form action="/admin/verify/" method="GET"><input type="text" name="oauth_verifier" /><input type="submit" /></form>'
)
# Save the tokens to the datastore for later authentication
oauth_token = credentials['oauth_token']
oauth_token_secret = credentials['oauth_token_secret']
# Record the tokens
opt = Option(name='oauth-request-token', value=oauth_token)
opt.put()
opt = Option(name='oauth-request-token-secret',
value=oauth_token_secret)
opt.put()
elif action == 'verify':
# Used to verify an initiated registration request. Request tokens should
# by now be stored in the data store. Retrieve them and initiate a change.
twitter = OAuthApi(consumer_key, consumer_secret)
oauth_verifier = self.request.get('oauth_verifier')
options = Option.all()
options.filter('name =', 'oauth-request-token')
oauth_token = options.get()
options = Option.all()
options.filter('name =', 'oauth-request-token-secret')
oauth_token_secret = options.get()
# Form a request and ask Twitter to exchange request tokens for access tokens using
# an OAuth verifier (PIN code).
credentials = {
'oauth_token': oauth_token.value,
'oauth_token_secret': oauth_token_secret.value,
'oauth_callback_confirmed': 'true'
}
credentials = twitter.getAccessToken(credentials, oauth_verifier)
# Record the access tokens and remove the previously stored request tokens.
access_token = Option(name='oauth-access-token',
value=credentials['oauth_token'])
access_token_secret = Option(
name='oauth-access-token-secret',
value=credentials['oauth_token_secret'])
oauth_token.delete()
oauth_token_secret.delete()
access_token.put()
access_token_secret.put()
# Tokens are now saved, getTwitterObject can be used.
self.response.out.write("You are now registered as @%s!" %
credentials['screen_name'])
# Uses the Task Queues API
elif action == 'cron':
if self.request.get('task') == 'geocode':
for i in range(2, 140, 2):
deferred.defer(tasks.geocode,
_countdown=i,
_queue='geocoding')
rendertext(self, "Geo task added to queue")
#!/usr/bin/env python
from oauthtwitter import OAuthApi
from settings import OAUTH_SETTINGS
twitter = OAuthApi(OAUTH_SETTINGS['consumer_key'], OAUTH_SETTINGS['consumer_secret'])
credenciales = twitter.getRequestToken()
print twitter.getAuthorizationURL(credenciales)
pin = input('INGRESA TU PIN: ')
access_token = twitter.getAccessToken(credenciales, pin)
print "OAuth Token: " + access_token['oauth_token']
print "OAuth Token Secret: " + access_token['oauth_token_secret']
import tstatus2
from bitly_api import Connection
from oauthtwitter import OAuthApi
from twitter import Api
import oauth.oauth as oauth
C_KEY = "c1z2SA8p1EAXthvpCrYUA"
C_SECRET = "2Qh67Sf2I9iV13apPtdNXvQTwQ5NikJZRTjiQ9Gagac"
t1 = OAuthApi(C_KEY, C_SECRET)
r_token = t1.getRequestToken()
t2 = OAuthApi(C_KEY, C_SECRET, r_token)
a_token = t2.getAccessToken()
t = Api(C_KEY, C_SECRET, a_token)
b = Connection('acompa', 'R_9c2643b4c8c85a250493e90ce27a624d')
tstatus2.getHighFive(b, t, "achompas")
def get_access_token(credentials,oauth_verifier):
twitter = OAuthApi(settings.consumer_key, settings.consumer_secret)
access_token = twitter.getAccessToken(credentials, oauth_verifier)
return access_token
def twitter_return(request):
"""
Get the Twitter auth tokens, check them and then create all the user-related database models
and subscribe to the pubsubhubbub server
"""
logger = get_fe_logger()
logger.info('On twitter_return')
if not request.session.has_key('gprofileusername'):
logger.debug('User doesnt have session on twitterreturn, redirecting to /')
return HttpResponseRedirect('/')
request_token = request.session.get('request_token', None)
if not request_token:
# Redirect the user to the login page,
# So the user can click on the sign-in with twitter button
logger.debug('User not sent to twitter by us on twitter_return()')
return HttpResponse("We didn't sent you to twitter...")
token = oauth.OAuthToken.from_string(request_token)
# If the token from session and token from twitter does not match
# means something bad happened to tokens
if token.key != request.GET.get('oauth_token', 'no-token'):
del request.session['request_token']
# Redirect the user to the login page
logger.debug('Tokens doesnt match for user')
return HttpResponse("Something wrong! Tokens do not match...")
twitter = OAuthApi(settings.CONSUMER_KEY, settings.CONSUMER_SECRET, token)
try:
access_token = twitter.getAccessToken()
except HTTPError:
logger.warning('Access denied on twitter.getAccessToken()')
return HttpResponseRedirect('/')
# Somewhat clumsy to create it again, but its the way oauthapi-twitter works...
twitter = OAuthApi(settings.CONSUMER_KEY, settings.CONSUMER_SECRET, access_token)
twuser = twitter.GetUserInfo()
# Now that we have the Twitter account we can create all the user-related models
googlename = request.session['gprofileusername']
userhash = hashlib.sha256( settings.MD5SALT + googlename).hexdigest()
# SiteUser
siteuser = SiteUser(userhash=userhash)
siteuser.save()
# GoogleProfile
gprofile = GoogleProfile(username=googlename, siteuser=siteuser)
gprofile.save()
# Initialize lastbuffread_at to created_at - 2 minutes (so we account for server time diffs)
gprofile.lastbuffread_at = gprofile.created_at - timedelta(minutes=2)
logger.debug('GProfile created_at : %s' % str(gprofile.created_at))
logger.debug('GProfile lastbuff_at: %s' % str(gprofile.lastbuffread_at))
gprofile.save()
# UserSettings
usettings = UserSettings(siteuser=siteuser)
usettings.save()
logger.info('Saved new SiteUser %d [%s]' % (siteuser.id, googlename))
# TwitterAccount
twname = twuser.GetScreenName()
twitteraccount = TwitterAccount(name=twname, token = access_token.to_string(), siteuser=siteuser)
twitteraccount.save()
# Send the ticket for subscribing to the push server
messenger = StompMessenger()
messenger.sendmessage('/queue/listener', 'subscribefeed__%d' % gprofile.id)
return render_to_response("settingsstep.html", {}, RequestContext(request, {'userhash': userhash}))
def get(self, action):
# Depending on the action requested /admin/<action>/
if action == 'register':
# Register a Twitter user with the application using
# OAuth. Works with the Option model to store the request and
# access tokens.
# Remove all the previous tokens matching oauth-* from the datastore.
options = Option.all()
options.filter('name >=', 'oauth-').filter('name <', 'oauth-' + u'\ufffd')
options.fetch(1000)
for option in options:
option.delete()
# Request an OAuth token and show the authorization URL on Twitter.
twitter = OAuthApi(consumer_key, consumer_secret)
credentials = twitter.getRequestToken()
url = twitter.getAuthorizationURL(credentials)
rendertext(self, '<a href="%s">%s</a><br />' % (url, url))
rendertext(self, '<form action="/admin/verify/" method="GET"><input type="text" name="oauth_verifier" /><input type="submit" /></form>')
# Save the tokens to the datastore for later authentication
oauth_token = credentials['oauth_token']
oauth_token_secret = credentials['oauth_token_secret']
# Record the tokens
opt = Option(name='oauth-request-token', value=oauth_token)
opt.put()
opt = Option(name='oauth-request-token-secret', value=oauth_token_secret)
opt.put()
elif action == 'verify':
# Used to verify an initiated registration request. Request tokens should
# by now be stored in the data store. Retrieve them and initiate a change.
twitter = OAuthApi(consumer_key, consumer_secret)
oauth_verifier = self.request.get('oauth_verifier')
options = Option.all()
options.filter('name =', 'oauth-request-token')
oauth_token = options.get()
options = Option.all()
options.filter('name =', 'oauth-request-token-secret')
oauth_token_secret = options.get()
# Form a request and ask Twitter to exchange request tokens for access tokens using
# an OAuth verifier (PIN code).
credentials = {'oauth_token': oauth_token.value, 'oauth_token_secret': oauth_token_secret.value, 'oauth_callback_confirmed': 'true'}
credentials = twitter.getAccessToken(credentials, oauth_verifier)
# Record the access tokens and remove the previously stored request tokens.
access_token = Option(name='oauth-access-token', value=credentials['oauth_token'])
access_token_secret = Option(name='oauth-access-token-secret', value=credentials['oauth_token_secret'])
oauth_token.delete()
oauth_token_secret.delete()
access_token.put()
access_token_secret.put()
# Tokens are now saved, getTwitterObject can be used.
self.response.out.write("You are now registered as @%s!" % credentials['screen_name'])
# Uses the Task Queues API
elif action == 'cron':
if self.request.get('task') == 'geocode':
for i in range(2, 140, 2):
deferred.defer(tasks.geocode, _countdown=i, _queue='geocoding')
rendertext(self, "Geo task added to queue")
