def get_verification():
#get the verifier key from the request url
verifier = request.args['oauth_verifier']
print(verifier)
auth = OAuthHandler(CONSUMER_TOKEN, CONSUMER_SECRET)
auth.request_token = {
'oauth_token': request.args.get('oauth_token'),
'oauth_token_secret': request.args.get('oauth_verifier')
}
# token = session['request_token']
del session_t['request_token']
# auth.set_request_token(token[0], token[1])
try:
auth.get_access_token(verifier)
print('obtuve el access token')
print(auth.access_token)
print(auth.access_token_secret)
print('termine')
except tweepy.TweepError:
print('Error! Failed to get access token.')
#now you have access!
api = tweepy.API(auth)
#store in a db
bdd['api'] = api
bdd['access_token_key'] = auth.access_token
bdd['access_token_secret'] = auth.access_token_secret
print(bdd)
return flask.redirect(flask.url_for('start'))
def cmd_verify(bot, update, args, chat):
if restrict_access(bot, update):
return
if not chat.twitter_request_token:
bot.reply(update, "Use /auth command first")
return
if len(args) < 1:
bot.reply(update, "No verifier code specified")
return
verifier_code = args[0]
auth = OAuthHandler(bot.tw.auth.consumer_key, bot.tw.auth.consumer_secret)
auth.request_token = json.loads(chat.twitter_request_token)
try:
auth.get_access_token(verifier_code)
except TweepError:
bot.reply(update, "Invalid verifier code. Use /auth again")
return
chat.twitter_token = auth.access_token
chat.twitter_secret = auth.access_token_secret
chat.save()
bot.reply(update, "Access token setup complete")
api = tweepy.API(auth)
settings = api.get_settings()
tz_name = settings.get("time_zone", {}).get("tzinfo_name")
cmd_set_timezone(bot, update, [tz_name])
def cmd_verify(update: telegram.Update, context: CallbackContext) -> None:
args = context.args
bot = context.bot
chat, _created = TelegramChat.get_or_create(
chat_id=update.message.chat.id,
tg_type=update.message.chat.type,
)
if not chat.twitter_request_token:
bot.reply(update, "Use /auth command first")
return
if len(args) < 1:
bot.reply(update, "No verifier code specified")
return
verifier_code = args[0]
auth = OAuthHandler(bot.tw.auth.consumer_key, bot.tw.auth.consumer_secret)
auth.request_token = json.loads(chat.twitter_request_token)
try:
auth.get_access_token(verifier_code)
except TweepyException:
bot.reply(update, "Invalid verifier code. Use /auth again")
return
chat.twitter_token = auth.access_token
chat.twitter_secret = auth.access_token_secret
chat.save()
bot.reply(update, "Access token setup complete")
api = tweepy.API(auth)
settings = api.get_settings()
tz_name = settings.get("time_zone", {}).get("tzinfo_name")
def get(self):
verifier = self.request.GET.get('oauth_verifier')
user = users.get_current_user()
if not user:
logging.warning("current user is not logged in")
self.redirect("/")
logging.info("running callback for user: %s" % user.user_id())
social_users = model.SocialKeysForUsers.all()
social_users.filter("user_id =",user.user_id())
user_model = social_users.get()
if not user_model == None and user_model.request_token_key and user_model.request_token_secret:
try:
auth = OAuthHandler(social_keys.TWITTER_CONSUMER_KEY, social_keys.TWITTER_CONSUMER_SECRET)
auth.set_request_token(user_model.request_token_key, user_model.request_token_secret)
auth.get_access_token(verifier)
user_model.access_token_key = auth.access_token.key
user_model.access_token_secret = auth.access_token.secret
api = API(auth)
api_is_working = api.test()
user_model.shortcut_social_username = api.me().screen_name
user_model.put()
memcache.add("twitter_user:%s" % user.user_id(), user_model.shortcut_social_username, 60)
#self.response.out.write("twitter user name: %s\n" % user_model.shortcut_social_username)
logging.debug("user access tokens have been set")
self.redirect("/")
except TweepError:
logging.error( "TweepError error API is could not fetch me: %s" % user.user_id())
user_model.access_token_key = None
user_model.access_token_secret = None
user_model.put()
self.redirect(URL_STATIC_ERROR_DEFAULT)
except CapabilityDisabledError:
logging.error( "Capability Disabled Error could not write for: %s" % user.user_id())
self.redirect(URL_STATIC_ERROR_DEFAULT)
else:
logging.warning("user model is not setup correctly: %s for user % " % (user_model, user.user_id()))
self.redirect("/")
def get_token(self, oauth_token, oauth_token_secret, oauth_verifier):
auth = OAuthHandler(self._consumer_key, self._consumer_secret)
auth.request_token = {'oauth_token': oauth_token,
'oauth_token_secret': oauth_token_secret}
auth.get_access_token(oauth_verifier)
self._access_token = auth.access_token
self._access_token_secret = auth.access_token_secret
self._setup_apis()
return self._access_token, self._access_token_secret
def get(self):
#Set up our twitter auth object
config = self.app.config['twitter']
auth = OAuthHandler(config['consumer_key'], config['consumer_secret'], self.request.host_url + '/auth')
#Check the session state. If it contains a twitter token,
#The user has already gone through the authorization step
tkn = self.session.get('twitter')
if tkn:
#If we are on the second phase already
auth.set_request_token(tkn[0], tkn[1])
del self.session['twitter']
verifier = self.request.get('oauth_verifier')
if verifier:
#Get the verification code from the URL
auth.get_access_token(verifier)
me = API(auth).me()
#See if we already have a user that has this id.
results = User.query().filter(User.twitter_id == me.id).fetch()
if results:
user = results[0]
#Make sure all the properties are up-to-date
user.name = me.name
user.location = me.location
user.put()
else:
user = User(twitter_id=me.id, name=me.name, location=me.location)
user.put()
#The user_id should be part of the session
self.session['user'] = user.key.id()
self.redirect('/')
else:
#Grabs request_tokens and creates a URL for a redirect
redirect_url = auth.get_authorization_url(signin_with_twitter=True)
#Store the request_token information for the next step
self.session['twitter'] = (auth.request_token.key, auth.request_token.secret)
self.redirect(redirect_url)
def cmd_verify(bot, update, args, chat):
if not chat.twitter_request_token:
bot.reply(update, "Use /auth command first")
return
if len(args) < 1:
bot.reply(update, "No verifier code specified")
return
verifier_code = args[0]
auth = OAuthHandler(bot.tw.auth.consumer_key, bot.tw.auth.consumer_secret)
auth.request_token = json.loads(chat.twitter_request_token)
try:
auth.get_access_token(verifier_code)
except TweepError:
bot.reply(update, "Invalid verifier code. Use /auth again")
return
chat.twitter_token = auth.access_token
chat.twitter_secret = auth.access_token_secret
chat.save()
bot.reply(update, "Access token setup complete")
api = tweepy.API(auth)
settings = api.get_settings()
tz_name = settings.get("time_zone", {}).get("tzinfo_name")
cmd_set_timezone(bot, update, [tz_name])
def callback(request):
unauthed_token = request.session.get('unauthed_token', None)
if not unauthed_token:
return HttpResponse("No un-authed token cookie")
token = oauth.OAuthToken.from_string(unauthed_token)
if token.key != request.GET.get('oauth_token', 'no-token'):
return HttpResponse("Something went wrong! Tokens do not match")
verifier = request.GET.get('oauth_verifier')
handler = OAuthHandler(settings.TWITTER_CONSUMER_KEY,
settings.TWITTER_CONSUMER_SECRET,
secure=True)
handler.request_token = token
access_token = handler.get_access_token(verifier)
# save token against user
user = User.objects.get(pk=request.session['user_id'])
profile = user.get_profile()
profile.access_token = access_token.key
profile.access_token_secret = access_token.secret
profile.save()
redirect = reverse('fundraiser-page', kwargs={'fundraiser_id': profile.jg_page_id})
return HttpResponseRedirect(redirect)
def get(self):
verifier = self.request.GET.get('oauth_verifier')
user = users.get_current_user()
if not user:
logging.warning("current user is not logged in")
self.redirect("/")
logging.info("running callback for user: %s" % user.user_id())
social_users = model.SocialKeysForUsers.all()
social_users.filter("user_id =", user.user_id())
user_model = social_users.get()
if not user_model == None and user_model.request_token_key and user_model.request_token_secret:
try:
auth = OAuthHandler(social_keys.TWITTER_CONSUMER_KEY,
social_keys.TWITTER_CONSUMER_SECRET)
auth.set_request_token(user_model.request_token_key,
user_model.request_token_secret)
auth.get_access_token(verifier)
user_model.access_token_key = auth.access_token.key
user_model.access_token_secret = auth.access_token.secret
api = API(auth)
api_is_working = api.test()
user_model.shortcut_social_username = api.me().screen_name
user_model.put()
memcache.add("twitter_user:%s" % user.user_id(),
user_model.shortcut_social_username, 60)
#self.response.out.write("twitter user name: %s\n" % user_model.shortcut_social_username)
logging.debug("user access tokens have been set")
self.redirect("/")
except TweepError:
logging.error(
"TweepError error API is could not fetch me: %s" %
user.user_id())
user_model.access_token_key = None
user_model.access_token_secret = None
user_model.put()
self.redirect(URL_STATIC_ERROR_DEFAULT)
except CapabilityDisabledError:
logging.error(
"Capability Disabled Error could not write for: %s" %
user.user_id())
self.redirect(URL_STATIC_ERROR_DEFAULT)
else:
logging.warning(
"user model is not setup correctly: %s for user % " %
(user_model, user.user_id()))
self.redirect("/")
