def Auth(request):
"""docstring for Auth"""
twitter = OAuthApi(CONSUMER_KEY, CONSUMER_SECRET)
request_token = twitter.getRequestToken()
authorization_url = twitter.getAuthorizationURL(request_token)
request.session['request_token'] = request_token
return HttpResponseRedirect(authorization_url)
def main():
for user in getCollUsers().find():
if "access_token" in user and "twitter_credentials" in user:
#if user["screen_name"]=="rabshakeh":
print(user["screen_name"])
access_token = dict(urllib.parse.parse_qsl(user["access_token"]))
twitter = OAuthApi(consumer_key, consumer_secret,
access_token["oauth_token"],
access_token["oauth_token_secret"])
#user["twitter_credentials"] = twitter.VerifyCredentials()
user_timeline = twitter.GetHomeTimeline({"count": 5})
ut = getCollUnprocessedTweets()
for tweet in user_timeline:
tweet["inprocess"] = 0
tweet["for_user"] = int(user["id_str"])
tweet["created_at_utc"] = str(tweet["created_at"])
tweet["created_at"] = parseDatetime(tweet["created_at"])
tweet["newsrivr_userid_md5"] = [user["newsrivr_userid_md5"]]
insertTweet(tweet["id_str"], user["newsrivr_userid_md5"],
tweet)
friends = twitter.GetFriendsIDs()
friend_list = []
for fp in friends:
friend_list.append(fp)
user["twitter_friend_list"] = friend_list
getCollUsers().save(user)
def TwitterApi(token=None):
"""
Returns an OAuthApi object, given an optional `token`.
"""
# Use the default consumer key and secret from settings.
return OAuthApi(consumer_key=settings.TWITTER_CONSUMER_KEY,
consumer_secret=settings.TWITTER_CONSUMER_SECRET,
access_token=token)
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 getTwitterObject():
options = Option.all()
options.filter('name =', 'oauth-access-token')
access_token = options.get()
options = Option.all()
options.filter('name =', 'oauth-access-token-secret')
access_token_secret = options.get()
twitter = OAuthApi(consumer_key, consumer_secret, access_token.value,
access_token_secret.value)
return twitter
def auth(request):
logger = get_fe_logger()
logger.info('On auth')
if not request.session.has_key('gprofileusername'):
logger.debug('User doesnt have session on auth(), redirecting to /')
return HttpResponseRedirect('/')
twitter = OAuthApi(settings.CONSUMER_KEY, settings.CONSUMER_SECRET)
request_token = twitter.getRequestToken()
request.session['request_token'] = request_token.to_string()
authorization_url = twitter.getAuthorizationURL(request_token)
logger.debug('Sending user to authorization URL %s' % authorization_url)
return HttpResponseRedirect(authorization_url)
def main():
access_token = dict(
urlparse.parse_qsl(
"oauth_token_secret=XwWBUDkHnaswXueyaKVBEe9m49iuIUWYx9fqGZKIG4&oauth_token=223480661-ZT7pgB8X5E8ez3DEvcIT2B66o9T8rQPKMbvqlYiY"
))
twitter = OAuthApi(consumer_key, consumer_secret,
access_token["oauth_token"],
access_token["oauth_token_secret"])
#print twitter.GetHomeTimeline({"count":200})
scoble = eval(open("scoble.json", "r").read())
print "len:", len(scoble)
done = []
for i in range(0, len(scoble)):
id = scoble[len(scoble) - 1 - i]
print twitter.FollowUser(str(id))
done.append(id)
#print id
open("done.p", "w").write(pickle.dumps(done))
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 setup_api(self):
self.twitter = OAuthApi(self.consumer_key,
self.consumer_secret,
self.token,
self.secret)
#!/usr/bin/env python
import oauth2 as oauth
from oauthtwitter import OAuthApi
import pprint
consumer_key = ""
consumer_secret = ""
access_tok = ""
access_tok_secret = ""
if access_tok == "":
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))
oauth_verifier = raw_input('What is the Verifier? ')
access_token = twitter.getAccessToken(temp_credentials, oauth_verifier)
print("oauth access token: " + access_token['oauth_token'])
print("oauth access token secret: " + access_token['oauth_token_secret'])
access_tok = access_token['oauth_token']
access_tok_secret = access_token['oauth_token_secret']
def GetRequest(self):
vOauthApi = OAuthApi(self.CONSUMER_KEY, self.CONSUMER_SECRET)
self.mOauthRequestToken = vOauthApi.getRequestToken(
self.REQUEST_TOKEN_URL)
self.mOauthRequestUrl = vOauthApi.getAuthorizationURL(
self.mOauthRequestToken)
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 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()
config_fname = os.path.expanduser('~') + '/.my_stupid_twitter'
tweets_fname = os.path.expanduser('~') + '/.my_stupid_twitts'
# Read config file
if os.path.exists(config_fname):
f = open(config_fname, 'rb')
config = pickle.load(f)
f.close()
else:
config = dict()
config['consumer_key'] = raw_input('What is the consumer key? ')
config['consumer_secret'] = raw_input('What is the consumer secret? ')
# Request app's authorization
twitter = OAuthApi(config['consumer_key'], config['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_tokens = twitter.getAccessToken(temp_credentials, oauth_verifier)
config['oauth_token'] = access_tokens['oauth_token']
config['oauth_token_secret'] = access_tokens['oauth_token_secret']
f = open(config_fname, 'wb')
pickle.dump(config, f)
class Bot:
# its supposed that all bots will interact using twitter and
# facebook apps
# tw_data={'mood':10, # mood affects the behaviour
# 'tuser':'', # twitter username
# 'tpass':'', # twitter password
# 'consumer_key':'',
# 'consumer_secret':'',
# 'atoken':'',
# 'stoken':''}
mood = 10.0 # mood affects the behaviour
tuser = '' # twitter username
tpass = '' # twitter password
consumer_key = ''
consumer_secret = ''
atoken = ''
stoken = ''
tApi = OAuthApi(consumer_key, consumer_secret) # Api
email = '' # respectable bots have a valid email
# Should be a service providing an API
emailpass = ''
message = '' # for messages construction
def random_item(self, token):
"""Picks a random item from a list.
"""
return token[int(random.random() * len(token))]
def twit_authenticate(self):
"""Begin a twitter session.
"""
self.tApi = OAuthApi(self.consumer_key, self.consumer_secret,
self.atoken, self.stoken)
def twit_deauthenticate(self): #deprecated
#self.tApi.ClearCredentials()
"""Deprecated.
Left for compatibility with older versions.
"""
pass
def twit_twit(self, token):
"""Post a new status.
"""
self.tApi.UpdateStatus(token[0:140])
def twit_get_user_updates(self, usrname, num):
"""Get the last updates from a specific user.
"""
return self.tApi.GetUserTimeline(user=usrname, count=num)
def Bot_sleep_random(self, ctime, sigtime):
""" Sleep a randomized amount of time.
"""
time.sleep(random.gauss(mu=ctime, sigma=sigtime))
def Bot_sleep(self, token):
""" Sleep a fixed amount of time
"""
time.sleep(token) # token in seconds
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 twit_authenticate(self):
"""Begin a twitter session.
"""
self.tApi = OAuthApi(self.consumer_key, self.consumer_secret,
self.atoken, self.stoken)
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")
def twitter_signin(request):
twitter = OAuthApi(CONSUMER_KEY, CONSUMER_SECRET)
request_token = twitter.getRequestToken()
request.session['request_token'] = request_token.to_string()
signin_url = twitter.getSigninURL(request_token)
return HttpResponseRedirect(signin_url)
