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 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 _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 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 begin_handshake( self, request ): twitter = OAuthApi( TWITTER_KEY, TWITTER_SECRET ) request.session[ 'request_token' ] = twitter.getRequestToken() redirect_url = twitter.getAuthorizationURL(request.session[ 'request_token' ] ) redirect_url = redirect_url[0:redirect_url.find( 'oauth_callback=None' )-2] redirect_url = redirect_url.replace( 'http://twitter.com/oauth/authorize', 'http://twitter.com/oauth/authenticate' ) return HttpResponseRedirect( redirect_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 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 oauth_login(request):
twitter = OAuthApi(CONSUMER_KEY, CONSUMER_SECRET)
req_token = twitter.getRequestToken()
request.session['request_token'] = req_token.to_string()
signin_url = twitter.getSigninURL(req_token)
return redirect(signin_url)
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 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 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 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 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_redirect(request):
oauth = OAuthApi(settings.TWITTER['CONSUMER_KEY'], settings.TWITTER['CONSUMER_SECRET'])
request_token = oauth.getRequestToken()
request.session['duration'] = request.POST['duration']
request.session['twitter_request_token'] = request_token
authorization_url = oauth.getAuthorizationURL(request_token)
return redirect(authorization_url)
def __init__(self, access_token, hrafn_obj):
OAuthApi.__init__(self, CONSUMER_KEY, CONSUMER_SECRET, access_token)
self.lock = RLock()
self.username = self.GetUserInfo().screen_name
self._username = self.username
thread = GetUserLists(self, hrafn_obj).start()
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 initiate_login(request):
if request.method != 'POST':
r = HttpResponse()
r.status_code = 405
return r
oauth = OAuthApi(
settings.D51_DJANGO_AUTH['TWITTER']['CONSUMER_KEY'],
settings.D51_DJANGO_AUTH['TWITTER']['CONSUMER_SECRET']
)
request_token = oauth.getRequestToken()
request.session['twitter_request_token'] = request_token
authorization_url = oauth.getAuthorizationURL(request_token)
return redirect(authorization_url)
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 initiate_login(request, redirect_field_name = auth.REDIRECT_FIELD_NAME):
if request.method != 'POST':
r = HttpResponse()
r.status_code = 405
return r
oauth = OAuthApi(
settings.D51_DJANGO_AUTH['TWITTER']['CONSUMER_KEY'],
settings.D51_DJANGO_AUTH['TWITTER']['CONSUMER_SECRET']
)
request_token = oauth.getRequestToken()
request.session['twitter_request_token'] = request_token
request.session['redirect_to'] = request.REQUEST.get(redirect_field_name, '/')
authorization_url = oauth.getAuthorizationURL(request_token)
return redirect(authorization_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 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 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 _authorizeBootstrap(self):
"""
"""
oauth_api = OAuthApi(CONSUMER_KEY, CONSUMER_SECRET)
request_token = oauth_api.getRequestToken()
pin = self.guiHandle.requestAuthPin(oauth_api.getAuthorizationURL(request_token))
if (not pin) or (isinstance(pin, str) and not pin.isdigit()):
# I rather do this ugly check than catch this later and have no clue
# of what is causing the erro
raise AuthFail("The retrieved pin is not valid")
self._access_token = OAuthApi(CONSUMER_KEY, CONSUMER_SECRET, request_token).getAccessToken(pin)
# Lets write this access token to a filename to reload it next time
# Lets check if directory .tnt exists
directory = os.environ["HOME"] + "/.tnt"
if not (os.path.exists(directory) and os.path.isdir(directory)):
os.mkdir(directory)
file = open(ACCESS_TOKEN_FILENAME, "w")
pickle.dump(self._access_token, file)
file.close()
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))
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()
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 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 get(self):
# check session
session = self.get_vaild_session(extend=False)
if session:
self.delete_session(session)
# get request token
twit = OAuthApi()
try:
req_token = twit.getRequestToken()
except DownloadError:
self.redirect_error(msg="twitter is over capacity")
return
# return url control
return_url = urllib.unquote(self.request.get('return_url'))
# insert request token into DB
fetcher.put_req_token(req_token.key, req_token.secret, return_url)
# redirect user to twitter auth page
auth_url = twit.getAuthorizationURL(req_token)
self.redirect(auth_url)
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 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")
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()
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()
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 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 CliTwi(object):
consumer_key = config.consumer_key
consumer_secret = config.consumer_secret
cli_twi_path = os.path.expanduser('~') + '/.clitwi'
token = None
secret = None
config_ok = False
def __init__(self):
os.chdir(self.cli_twi_path)
# Figure out the action
self.read_action()
# Verify we have all of the necessary config files
self.check_config()
self.read_config()
# And the power button...
self.run()
def read_action(self):
l = len(sys.argv)
if l == 1:
self.action = 'list'
elif l == 2:
arg = sys.argv[1]
if arg == 'setup':
self.action = 'setup'
elif arg == '-m':
self.action = 'mentions'
elif arg == '--help':
self.action = 'help'
else:
self.action = 'update'
def check_config(self):
self.config_ok = True
if not os.path.isfile('_config'):
print 'Missing _config'
self.config_ok = False
def read_config(self):
if self.action == 'setup' or self.action == 'help':
return
if not self.config_ok:
return
# Read the config file
file = open('_config', 'r')
v = file.read()
config = json.loads(v)
file.close()
self.latest = config['latest']
self.mention = config['mention']
self.token = config['token']
self.secret = config['secret']
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 setup_api(self):
self.twitter = OAuthApi(self.consumer_key,
self.consumer_secret,
self.token,
self.secret)
def list_tweets(self, type='default'):
os.system('clear')
if type == 'default':
user_timeline = self.twitter.GetHomeTimeline({
'since_id': self.latest
})
else:
user_timeline = self.twitter.GetMentions({
'since_id': self.mention
})
if user_timeline == []:
print 'No new tweets.'
return
first = True
for tweet in user_timeline:
print tweet['user']['screen_name'] + ':'
self.print_text(tweet['text'])
if first:
if type == 'default':
self.latest = tweet['id']
else:
self.mention = tweet['id']
first = False
def print_text(self, text):
l = len(text)
if l > 77:
print ' ' + text[:77]
print ' ' + text[77:]
else:
print ' ' + text
def send_tweet(self):
tweet = sys.argv[1]
if len(tweet) > 140:
print 'Too long'
sys.exit(1)
return
else:
self.twitter.UpdateStatus(str(tweet))
print 'Sent!'
def show_help(self):
print 'Cli Twi - version %s' % __version__
print 'main.py [options]'
print 'main.py - will print latest tweets'
print 'main.py "Some message" - will update your status'
print 'main.py -m - will print latest mentions'
print 'main.py setup - will run the OAuth process'
print 'main.py --help - will display this help'
def run(self):
# Actions that don't require any config (help, setup)
if self.action == 'setup':
self.setup()
elif self.action == 'help':
self.show_help()
# Check if we have correct config settings
if not self.config_ok:
return
self.setup_api()
if self.action == 'list':
self.list_tweets()
elif self.action == 'update':
self.send_tweet()
elif self.action == 'mentions':
self.list_tweets('mentions')
def finish(self):
d = {
'token': self.token,
'secret': self.secret,
'latest': self.latest,
'mention': self.mention
}
f = open(os.getcwd() + '/_config', 'w')
f.write(json.dumps(d))
f.close()
def setup_api(self):
self.twitter = OAuthApi(self.consumer_key,
self.consumer_secret,
self.token,
self.secret)
"""
import sys
import os
sys.path.insert(0,'../')
import ConfigParser
config = ConfigParser.ConfigParser()
config.read(os.path.join(os.path.dirname(__file__), '../cfg.ini'))
from oauthtwitter import OAuthApi
import pprint
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'])
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 twit_authenticate(self):
"""Begin a twitter session.
"""
self.tApi = OAuthApi(self.consumer_key, self.consumer_secret,
self.atoken, self.stoken)
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
import datetime
from oauth import oauth
from oauthtwitter import OAuthApi
import smtplib
import email
from email.MIMEText import MIMEText
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email import encoders
import smtplib
import mimetypes
from config import *
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))
# Do a test API call using our new credentials
#twitter = OAuthApi(consumer_key, consumer_secret, access_token['oauth_token'], access_token['oauth_token_secret'])
user_timeline = twitter.GetUserTimeline({
"trim_user": True,
"screen_name": screen_name,
"count": 200
})
#!/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']
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)
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)
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)
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 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 GetRequest(self):
vOauthApi = OAuthApi(self.CONSUMER_KEY, self.CONSUMER_SECRET)
self.mOauthRequestToken = vOauthApi.getRequestToken(self.REQUEST_TOKEN_URL)
self.mOauthRequestUrl = vOauthApi.getAuthorizationURL(self.mOauthRequestToken)
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}))
