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}))