def twitter_callback(request):
twitter = Twython(
settings.TWITTER_KEY, settings.TWITTER_SECRET, TWITTER_OAUTH_TOKEN, request.session.get("oauth_token_secret")
)
authorized_tokens = twitter.get_authorized_tokens(request.GET.get("oauth_verifier"))
try:
profile = UserProfile.objects.get(screen_name=authorized_tokens["screen_name"])
user = User.objects.get(pk=profile.user_id)
user.backend = "django.contrib.auth.backends.ModelBackend"
if user.is_active:
auth_login(request, user)
return HttpResponseRedirect("/")
else:
return HttpResponseRedirect("/accounts/login/")
except UserProfile.DoesNotExist:
name = (authorized_tokens["screen_name"],)
oauth_token = (authorized_tokens["oauth_token"],)
oauth_token_secret = (authorized_tokens["oauth_token_secret"],)
user = add_user(name, oauth_token_secret, "*****@*****.**")
create_twitter_profile(user.id, oauth_token, oauth_token_secret, name)
user = authenticate(username=name, password=oauth_token_secret)
auth_login(request, user)
return HttpResponseRedirect("/")
class Twitter:
def __init__(self,
app_key=TWITTER_APP_KEY,
app_secret=TWITTER_APP_SECRET,
oauth_token=None,
oauth_token_secret=None):
self.app_key = app_key
self.app_secret = app_secret
self.oauth_token = oauth_token
self.oauth_token_secret = oauth_token_secret
self.update_client()
def update_client(self):
self.client = Twython(self.app_key, self.app_secret, self.oauth_token,
self.oauth_token_secret)
def login(self):
auth = self.client.get_authentication_tokens()
self.oauth_token = auth['oauth_token']
self.oauth_token_secret = auth['oauth_token_secret']
return auth
def confirm_login(self, oauth_verifier):
self.update_client()
login_res = self.client.get_authorized_tokens(oauth_verifier)
self.oauth_token = login_res['oauth_token']
self.oauth_token_secret = login_res['oauth_token_secret']
self.update_client()
return self.client.verify_credentials()
def get_user_info(self):
user_info = self.client.verify_credentials()
return user_info
def oauth_callback(request):
# request.session['oauth_token_secret'] = '0PNq6EWVWLuGDD7Zz1Y5aiMGc0eavJ6b2lKFaFUSLkqJy'
# request.session['oauth_token'] = '41803203-daelXLCmfUn9NRxwawmDSnu1nQSDdXG9fpinUwm4y'
if not 'oauth_token' in request.GET or not 'oauth_verifier' in request.GET:
return render(request, 'message.html', {'message': 'Invalid request', 'type': 'warning'})
elif request.GET['oauth_token'] != request.session['oauth_token']:
return render(request, 'message.html', {'message': "Trying an attack?", 'type': 'danger'})
else:
oauth_verifier = request.GET['oauth_verifier']
twitter = Twython(
settings.TWITTER_APP_KEY,
settings.TWITTER_APP_SECRET,
request.session['oauth_token'],
request.session['oauth_token_secret']
)
# convert request token to access token
auth = twitter.get_authorized_tokens(oauth_verifier)
request.session['oauth_token'] = auth['oauth_token']
request.session['oauth_token_secret'] = auth['oauth_token_secret']
# request.session['oauth_token_secret'] = '0PNq6EWVWLuGDD7Zz1Y5aiMGc0eavJ6b2lKFaFUSLkqJy'
# request.session['oauth_token'] = '41803203-daelXLCmfUn9NRxwawmDSnu1nQSDdXG9fpinUwm4y'
current_username = createDatabase(request);
request.session['authorized'] = 1
f = open(os.path.dirname(__file__) + '/current_user.txt', "w")
f.write(current_username)
f.close()
return redirect(mainapp)
def Authentication():
APP_KEY = 'b1WTyzKmLnG7KwnDcYpiQ'
APP_SECRET = 'gzKci8Gys0i831zt7gPq3fEpG4qq9kgOINfbKhS8'
twitter = Twython(APP_KEY, APP_SECRET)
auth = twitter.get_authentication_tokens()
OAUTH_TOKEN = auth['oauth_token']
OAUTH_TOKEN_SECRET = auth['oauth_token_secret']
webbrowser.open(auth['auth_url'])
twitter = Twython(APP_KEY, APP_SECRET, OAUTH_TOKEN, OAUTH_TOKEN_SECRET)
final_step = twitter.get_authorized_tokens(
str(raw_input("Please enter the PIN: "))
) #atm pin must be entered through the terminal
OAUTH_TOKEN = final_step['oauth_token']
OAUTH_TOKEN_SECRET = final_step['oauth_token_secret']
print APP_KEY, APP_SECRET, OAUTH_TOKEN, OAUTH_TOKEN_SECRET
twitter = Twython(APP_KEY, APP_SECRET, OAUTH_TOKEN, OAUTH_TOKEN_SECRET)
return twitter
def callback(request):
if request.method == 'GET':
oauth_verifier = request.GET['oauth_verifier']
twitter = Twython(creds.APP_KEY, creds.APP_SECRET,
request.GET['oauth_token'],
request.session['oauth_token_secret'])
final_step = twitter.get_authorized_tokens(oauth_verifier)
request.session['oauth_token'] = final_step['oauth_token']
request.session['oauth_token_secret'] = final_step[
'oauth_token_secret']
try:
user = User.objects.get(username=final_step['screen_name'])
profile = user.twitterprofile
profile.oauth_token = final_step['oauth_token']
profile.oauth_secret = final_step['oauth_token_secret']
profile.save()
except ObjectDoesNotExist:
user = User.objects.create_user(final_step['screen_name'],
"*****@*****.**", 'the_password')
profile = TwitterProfile()
profile.user = user
profile.oauth_token = final_step['oauth_token']
profile.oauth_secret = final_step['oauth_token_secret']
profile.save()
finally:
user = authenticate(username=final_step['screen_name'],
password='******')
login(request, user)
return redirect(reverse(account))
def callback(request):
oauth_verifier = request.GET['oauth_verifier']
oauth_token = request.GET['oauth_token']
twitter = Twython(APP_KEY, APP_SECRET, oauth_token, oauth_verifier)
final_step = twitter.get_authorized_tokens(oauth_verifier)
# Generate final token and secret and save them into db
OAUTH_TOKEN = final_step['oauth_token']
OAUTH_TOKEN_SECRET = final_step['oauth_token_secret']
timeline = Twython(APP_KEY, APP_SECRET, OAUTH_TOKEN, OAUTH_TOKEN_SECRET)
timeline.verify_credentials()
screen_name = timeline.verify_credentials()["screen_name"]
user_tweets = timeline.get_user_timeline(screen_name=screen_name,
include_rts=True)
# Get Messeges with help of custom function
home_timeline = oauth_req(
'https://api.twitter.com/1.1/direct_messages/events/list.json',
OAUTH_TOKEN, OAUTH_TOKEN_SECRET)
data = json.loads(home_timeline)
context = {
'oauth_token': OAUTH_TOKEN,
'token_secret': OAUTH_TOKEN_SECRET,
'all_tweets': user_tweets,
'all_messages': data,
}
return render(request, 'callback.html', context)
def twitter_token(request):
## Tomamos el absolute path de donde esta corriendo
callback = request.build_absolute_uri()
if request.GET:
auth = request.session['twitter_auth']
ttoken = auth['oauth_token']
tsecret = auth['oauth_token_secret']
verifier = request.GET['oauth_verifier']
twitter = Twython(settings.TW_KEY, settings.TW_SECRET, ttoken, tsecret)
oauth = twitter.get_authorized_tokens(verifier)
token = oauth['oauth_token']
secret = oauth['oauth_token_secret']
else:
twitter = Twython(settings.TW_KEY, settings.TW_SECRET)
## Se arma la URL para autenticar
auth = twitter.get_authentication_tokens(callback_url=callback)
url = auth['auth_url']
request.session['twitter_auth'] = auth
template = 'twitter_token.html'
return render(request, template, locals())
async def twitter_callback(request):
app = request.app
oauth_token = request.query['oauth_token']
oauth_verifier = request.query['oauth_verifier']
user = await db.get_user_by_token(app, oauth_token)
twitter = Twython(**app['settings']['twitter']['tokens'],
oauth_token=oauth_token,
oauth_token_secret=user.oauth_token_secret)
final_step = twitter.get_authorized_tokens(oauth_verifier)
twitter = Twython(**app['settings']['twitter']['tokens'],
oauth_token=final_step['oauth_token'],
oauth_token_secret=final_step['oauth_token_secret'])
profile = twitter.verify_credentials()
user = await db.get_user(app, profile['screen_name'])
if not user:
user = await db.update_user(
app, oauth_token, {
'oauth_token': final_step['oauth_token'],
'oauth_token_secret': final_step['oauth_token_secret'],
'fullname': profile['name'],
'username': profile['screen_name']
})
session = await get_session(request)
session['username'] = profile['screen_name']
return web.HTTPFound(location=app.router['home'].url_for())
def callback(photolog_id):
""" twitter로부터 callback url이 요청되었을때
최종인증을 한 후 트위터로 해당 사진과 커멘트를 전송한다.
"""
Log.info("callback oauth_token:" + request.args['oauth_token'])
Log.info("callback oauth_verifier:" + request.args['oauth_verifier'])
# oauth에서 twiter로 부터 넘겨받은 인증토큰을 세션으로 부터 가져온다.
OAUTH_TOKEN = session['OAUTH_TOKEN']
OAUTH_TOKEN_SECRET = session['OAUTH_TOKEN_SECRET']
oauth_verifier = request.args['oauth_verifier']
# 임시로 받은 인증토큰을 이용하여 twitter 객체를 만들고 인증토큰을 검증한다.
twitter = Twython(current_app.config['TWIT_APP_KEY'],
current_app.config['TWIT_APP_SECRET'], OAUTH_TOKEN,
OAUTH_TOKEN_SECRET)
final_step = twitter.get_authorized_tokens(oauth_verifier)
# oauth_verifier를 통해 얻은 최종 인증토큰을 이용하여 twitter 객체를 새로 생성한다.
twitter = Twython(current_app.config['TWIT_APP_KEY'],
current_app.config['TWIT_APP_SECRET'],
final_step['oauth_token'],
final_step['oauth_token_secret'])
session['TWITTER'] = twitter
# 파라미터로 받은 photolog_id를 이용하여 해당 사진과 커멘트를 트위터로 전송한다.
photo_info = get_photo_info(photolog_id)
download_filepath = photo_info[2]
photo_comment = photo_info[3]
photo = open(download_filepath, 'rb')
twitter.update_status_with_media(status=photo_comment, media=photo)
return redirect(url_for('.show_all'))
def _authorized():
"""
Callback for Twitter authentication.
"""
# Login failed
if request.args.get("denied", None) or request.args.get("oauth_token", "") != session["oauth_token"]:
session.pop("oauth_token", None)
session.pop("oauth_token_secret", None)
session.pop("screen_name", None)
return redirect(url_for("index"))
twitter = Twython(
secrets["TWITTER_CONSUMER_KEY"],
secrets["TWITTER_CONSUMER_SECRET"],
session["oauth_token"],
session["oauth_token_secret"],
)
auth = twitter.get_authorized_tokens(request.args.get("oauth_verifier"))
session["oauth_token"] = auth["oauth_token"]
session["oauth_token_secret"] = auth["oauth_token_secret"]
session["screen_name"] = auth["screen_name"]
return redirect(url_for("index"))
def thanks(request, redirect_url=settings.LOGIN_REDIRECT_URL):
# tokens obtained from Twitter
oauth_token = request.session['request_token']['oauth_token']
oauth_token_secret = request.session['request_token']['oauth_token_secret']
twitter = Twython(settings.TWITTER_KEY, settings.TWITTER_SECRET,
oauth_token, oauth_token_secret)
# retrieving tokens
authorized_tokens = twitter.get_authorized_tokens(request.GET['oauth_verifier'])
# if tokens already exist, use them to login and redirect to the battle
try:
user = User.objects.get(username=authorized_tokens['screen_name'])
user.set_password(authorized_tokens['oauth_token_secret'])
user.save()
except User.DoesNotExist:
# mock a creation here; no email, password is just the token, etc. since no need for users in this app
user = User.objects.create_user(authorized_tokens['screen_name'], "*****@*****.**", authorized_tokens['oauth_token_secret'])
profile = TwitterProfile()
profile.user = user
profile.oauth_token = authorized_tokens['oauth_token']
profile.oauth_secret = authorized_tokens['oauth_token_secret']
profile.save()
user = authenticate(
username=authorized_tokens['screen_name'],
password=authorized_tokens['oauth_token_secret']
)
login(request, user)
return HttpResponseRedirect(redirect_url)
def get_authenticated_twitter():
try:
with open("./data/credentials.txt", "r") as file:
lines = file.readlines()
FINAL_OAUTH_TOKEN = lines[0][:-1]
FINAL_OAUTH_TOKEN_SECRET = lines[1]
twitter = Twython(APP_KEY, APP_SECRET, FINAL_OAUTH_TOKEN,
FINAL_OAUTH_TOKEN_SECRET)
twitter.verify_credentials()
return twitter
except:
twitter = Twython(APP_KEY, APP_SECRET)
auth = twitter.get_authentication_tokens()
OAUTH_TOKEN = auth['oauth_token']
OAUTH_TOKEN_SECRET = auth['oauth_token_secret']
print(auth['auth_url'])
oauth_verifier = input('Enter your pin:')
twitter = Twython(APP_KEY, APP_SECRET, OAUTH_TOKEN, OAUTH_TOKEN_SECRET)
final_step = twitter.get_authorized_tokens(oauth_verifier)
FINAL_OAUTH_TOKEN = final_step['oauth_token']
FINAL_OAUTH_TOKEN_SECRET = final_step['oauth_token_secret']
twitter = Twython(APP_KEY, APP_SECRET, FINAL_OAUTH_TOKEN,
FINAL_OAUTH_TOKEN_SECRET)
twitter.verify_credentials()
with open("./data/credentials.txt", "w") as file:
file.write(FINAL_OAUTH_TOKEN + "\n" + FINAL_OAUTH_TOKEN_SECRET)
return twitter
def login():
# rest of authentication process
oauth_verifier = request.args.get('oauth_verifier')
OAUTH_TOKEN = session['OAUTH_TOKEN']
OAUTH_TOKEN_SECRET = session['OAUTH_TOKEN_SECRET']
# temporary middle instance for receiving final tokens
twitter = Twython(APP_KEY, APP_SECRET, OAUTH_TOKEN, OAUTH_TOKEN_SECRET)
final_step = twitter.get_authorized_tokens(oauth_verifier)
session['OAUTH_TOKEN'] = final_step['oauth_token']
session['OAUTH_TOKEN_SECRET'] = final_step['oauth_token_secret']
OAUTH_TOKEN = session['OAUTH_TOKEN']
OAUTH_TOKEN_SECRET = session['OAUTH_TOKEN_SECRET']
# final instance to be used app-wide for user authenticated operations (Tweeting, DMs, etc.)
session['twitter'] = Twython(APP_KEY, APP_SECRET, OAUTH_TOKEN,
OAUTH_TOKEN_SECRET)
# get all user data of authenticated user for session log-in and app-wide use
session['screen_name'] = session['twitter'].verify_credentials()
session["dm"] = []
session["tweets_embed"] = []
session["mentions"] = []
session["followers"] = []
flash("You've logged in!")
return redirect('/')
def get_authorized_tokens(oauth_verifier, token, token_secret):
try:
try:
twitter_consumer_key = Option.objects.get(
parameter="twitter_consumer_key").value
twitter_consumer_secret = Option.objects.get(
parameter="twitter_consumer_secret").value
except:
raise Exception("Failed to retrieve the consumer keys.")
api = Twython(twitter_consumer_key, twitter_consumer_secret, token,
token_secret)
response = api.get_authorized_tokens(oauth_verifier)
return {
'status': True,
'oauth_token': response["oauth_token"],
'oauth_token_secret': response["oauth_token_secret"]
}
except Exception as e:
return {
'status': False,
'error': 'TwitterAPI.get_authorized_tokens(): Error: ' + str(e)
}
def handle_twitter_callback():
twitter = Twython(app.config['TWITTER_API_KEY'],app.config['TWITTER_API_SECRET'],
session['oauth_token'], session['oauth_token_secret'])
success = True
try:
final_step = twitter.get_authorized_tokens(request.json['oauth_verifier'])
user_oauth_token = final_step['oauth_token']
user_oauth_token_secret = final_step['oauth_token_secret']
user_twitter = Twython(app.config['TWITTER_API_KEY'],app.config['TWITTER_API_SECRET'],
user_oauth_token, user_oauth_token_secret)
twitter_user_show = user_twitter.show_user(user_id=final_step['user_id'])
current_user.set_twitter_data(final_step['user_id'], final_step['screen_name'], twitter_user_show)
new_twitter_auth = TwitterAuth(current_user.get_id(), user_oauth_token, user_oauth_token_secret)
db.session.add(new_twitter_auth)
db.session.commit()
tasks.get_tweets_per_user.delay(current_user.get_id())
# db.session.close()
except:
# print 'error in twitter auth'
success = False
return jsonify({'success': success})
def thanks(request):
"""A user gets redirected here after hitting Twitter and authorizing your app to use their data.
***
This is the view that stores the tokens you want
for querying data. Pay attention to this.
***
"""
# Now that we've got the magic tokens back from Twitter, we need to exchange
# for permanent ones and store them...
twitter = Twython(
twitter_token=settings.TWITTER_KEY,
twitter_secret=settings.TWITTER_SECRET,
oauth_token=request.session['request_token']['oauth_token'],
oauth_token_secret=request.session['request_token']['oauth_token_secret'],
)
# Retrieve the tokens we want...
authorized_tokens = twitter.get_authorized_tokens()
twitter_id = authorized_tokens['user_id']
request.session['twitter_id'] = twitter_id
if not User.objects.filter(twitter_id=twitter_id).exists():
user = User.objects.create(twitter_id=twitter_id)
return redirect('index')
def oauth1(self):
twitter = Twython(self.__APP_KEY, self.__APP_SECRET) #create twython object, v.1
auth = twitter.get_authentication_tokens() #get oauth v.1 tokens
OAUTH_TOKEN = auth['oauth_token'] #pull out of auth
OAUTH_TOKEN_SECRET = auth['oauth_token_secret'] #pull out of auth
with open('token2a.key','w') as f: #open file to store tokens key
f.write(OAUTH_TOKEN) #write token to file
f.write('\n') #newline to separate tokens
f.write(OAUTH_TOKEN_SECRET) #write token secret to file
print(auth['auth_url']) #print auth_url to screen
#user must follow and allow access to complete authorization, see oauth doc
oauth_verifier = input('Enter pin: ')
#reinstantiate twitter as twython object (authorized)
twitter = Twython(self.__APP_KEY, self.__APP_SECRET, OAUTH_TOKEN,
OAUTH_TOKEN_SECRET)
final_tokens = twitter.get_authorized_tokens(oauth_verifier) #final step
fot = final_tokens['oauth_token'] #final oauth token
fots = final_tokens['oauth_token_secret'] #final oauth secret token
#final tokens can be saved and used repeatedly in new objects
#twythonobj->authentication->verify->twythonobj2->authorization->storekeys
with open('token2f.key','w') as r:
r.write(fot)
r.write('\n')
r.write(fots)
def OnLaunchWeb(self, e):
twitter = Twython(self.APP_KEY, self.APP_SECRET)
auth = twitter.get_authentication_tokens()
self.OAUTH_TOKEN = auth['oauth_token']
self.OAUTH_TOKEN_SECRET = auth['oauth_token_secret']
self.url = auth["auth_url"]
webbrowser.open(self.url, new=2)
self.pinwindow = PinWindow(self)
self.pinwindow.ShowModal()
self.pin = self.pinwindow.pin
if self.pin is not None:
oauth_verifier = self.pin
twitter = Twython(self.APP_KEY, self.APP_SECRET, self.OAUTH_TOKEN,
self.OAUTH_TOKEN_SECRET)
final_step = twitter.get_authorized_tokens(oauth_verifier)
self.OAUTH_TOKEN = final_step['oauth_token']
self.OAUTH_TOKEN_SECRET = final_step['oauth_token_secret']
self.codes = [self.OAUTH_TOKEN, self.OAUTH_TOKEN_SECRET]
self.LoadScreenName()
else:
print("No pin provided")
def Authentication():
APP_KEY = 'b1WTyzKmLnG7KwnDcYpiQ'
APP_SECRET = 'gzKci8Gys0i831zt7gPq3fEpG4qq9kgOINfbKhS8'
twitter = Twython(APP_KEY, APP_SECRET)
auth = twitter.get_authentication_tokens()
OAUTH_TOKEN = auth ['oauth_token']
OAUTH_TOKEN_SECRET = auth['oauth_token_secret']
webbrowser.open(auth['auth_url'])
twitter = Twython(APP_KEY, APP_SECRET, OAUTH_TOKEN, OAUTH_TOKEN_SECRET)
final_step = twitter.get_authorized_tokens(str(raw_input("Please enter the PIN: "))) #atm pin must be entered through the terminal
OAUTH_TOKEN = final_step['oauth_token']
OAUTH_TOKEN_SECRET = final_step['oauth_token_secret']
print APP_KEY, APP_SECRET, OAUTH_TOKEN, OAUTH_TOKEN_SECRET
twitter = Twython(APP_KEY, APP_SECRET, OAUTH_TOKEN, OAUTH_TOKEN_SECRET)
return twitter
def callback(photolog_id):
""" twitter로부터 callback url이 요청되었을때
최종인증을 한 후 트위터로 해당 사진과 커멘트를 전송한다.
"""
Log.info("callback oauth_token:" + request.args['oauth_token']);
Log.info("callback oauth_verifier:" + request.args['oauth_verifier']);
# oauth에서 twiter로 부터 넘겨받은 인증토큰을 세션으로 부터 가져온다.
OAUTH_TOKEN = session['OAUTH_TOKEN']
OAUTH_TOKEN_SECRET = session['OAUTH_TOKEN_SECRET']
oauth_verifier = request.args['oauth_verifier']
try:
# 임시로 받은 인증토큰을 이용하여 twitter 객체를 만들고 인증토큰을 검증한다.
twitter = Twython(current_app.config['TWIT_APP_KEY'],
current_app.config['TWIT_APP_SECRET'],
OAUTH_TOKEN, OAUTH_TOKEN_SECRET)
final_step = twitter.get_authorized_tokens(oauth_verifier)
# oauth_verifier를 통해 얻은 최종 인증토큰을 이용하여 twitter 객체를 새로 생성한다.
twitter = Twython(current_app.config['TWIT_APP_KEY'],
current_app.config['TWIT_APP_SECRET'],
final_step['oauth_token'],
final_step['oauth_token_secret'])
session['TWITTER'] = twitter
# 파라미터로 받은 photolog_id를 이용하여 해당 사진과 커멘트를 트위터로 전송한다.
__send_twit(twitter, photolog_id)
except TwythonError as e:
Log.error("callback(): TwythonError , "+ str(e))
session['TWITTER_RESULT'] = str(e)
return redirect(url_for('.show_all'))
def config_twitter(config):
if 'twitter' in config.keys():
replace = input("Twitter configuration already exists. Replace? (Y/n) ")
if replace.lower() in ['n','no']:
return config
input("Create a new Twitter app at https://apps.twitter.com/app/new to post matching stories. For this step, you can be logged in as yourself or with the posting account, if they're different. Fill out Name, Description, and Website with values meaningful to you. These are not used in trackthenews config but may be publicly visible. Then click the \"Keys and Access Tokens\" tab. ")
api_key = input("Enter the provided API key: ")
api_secret = input("Enter the provided API secret: ")
input("Now ensure you are logged in with the account that will do the posting. ")
tw = Twython(api_key, api_secret)
auth = tw.get_authentication_tokens()
oauth_token = auth['oauth_token']
oauth_secret = auth['oauth_token_secret']
tw = Twython(api_key, api_secret, oauth_token, oauth_secret)
pin = input("Enter the pin found at {} ".format(auth['auth_url']))
final_step = tw.get_authorized_tokens(pin)
oauth_token = final_step['oauth_token']
oauth_secret = final_step['oauth_token_secret']
twitter = {'api_key': api_key, 'api_secret': api_secret,
'oauth_token': oauth_token, 'oauth_secret': oauth_secret}
config['twitter'] = twitter
return config
def callback(photolog_id):
""" twitter로부터 callback url이 요청되었을때
최종인증을 한 후 트위터로 해당 사진과 커멘트를 전송한다.
"""
Log.info("callback oauth_token:" + request.args['oauth_token']);
Log.info("callback oauth_verifier:" + request.args['oauth_verifier']);
# oauth에서 twiter로 부터 넘겨받은 인증토큰을 세션으로 부터 가져온다.
OAUTH_TOKEN = session['OAUTH_TOKEN']
OAUTH_TOKEN_SECRET = session['OAUTH_TOKEN_SECRET']
oauth_verifier = request.args['oauth_verifier']
# 임시로 받은 인증토큰을 이용하여 twitter 객체를 만들고 인증토큰을 검증한다.
twitter = Twython(current_app.config['TWIT_APP_KEY'],
current_app.config['TWIT_APP_SECRET'],
OAUTH_TOKEN, OAUTH_TOKEN_SECRET)
final_step = twitter.get_authorized_tokens(oauth_verifier)
# oauth_verifier를 통해 얻은 최종 인증토큰을 이용하여 twitter 객체를 새로 생성한다.
twitter = Twython(current_app.config['TWIT_APP_KEY'],
current_app.config['TWIT_APP_SECRET'],
final_step['oauth_token'],
final_step['oauth_token_secret'])
session['TWITTER'] = twitter
# 파라미터로 받은 photolog_id를 이용하여 해당 사진과 커멘트를 트위터로 전송한다.
photo_info = get_photo_info(photolog_id)
download_filepath = photo_info[2]
photo_comment = photo_info[3]
photo = open(download_filepath, 'rb')
twitter.update_status_with_media(status=photo_comment,
media=photo)
return redirect(url_for('.show_all'))
def twitterCallback(request):
oauthToken = request.session['requestToken']['oauth_token']
oauthTokenSecret = request.session['requestToken']['oauth_token_secret']
twitter = Twython(settings.TWITTER_KEY, settings.TWITTER_SECRET, oauthToken, oauthTokenSecret)
authorizedTokens = twitter.get_authorized_tokens(request.GET['oauth_verifier'])
request.session['userName'] = authorizedTokens['screen_name']
return redirect("/login/")
def GET(self):
data = web.input()
OAUTH_TOKEN = data.oauth_token
OAUTH_TOKEN_SECRET = web.cookies().get("OAUTH_TOKEN_SECRET")
APP_KEY = "##################"
APP_SECRET = "####################"
print OAUTH_TOKEN
print OAUTH_TOKEN_SECRET
heeey = Twython(APP_KEY, APP_SECRET, OAUTH_TOKEN, OAUTH_TOKEN_SECRET)
final_step = heeey.get_authorized_tokens(data.oauth_verifier)
OAUTH_TOKEN = final_step["oauth_token"]
print final_step
print "Ponto 1"
print OAUTH_TOKEN
print final_step["screen_name"]
OAUTH_TOKEN_SECRET = str(final_step).split("'")[3]
print OAUTH_TOKEN_SECRET
twitter = Twython(APP_KEY, APP_SECRET, OAUTH_TOKEN, OAUTH_TOKEN_SECRET)
print "Ponto 1.5"
web.setcookie("OAUTH_TOKEN", OAUTH_TOKEN, domain=".phckopper.org")
web.setcookie("OAUTH_TOKEN_SECRET", OAUTH_TOKEN_SECRET, domain=".phckopper.org")
web.setcookie("username", final_step["screen_name"], domain=".phckopper.org")
db.insert(
"users",
username=final_step["screen_name"],
access_token=OAUTH_TOKEN,
access_token_secret=OAUTH_TOKEN_SECRET,
bio="Heeeey new user here!",
profile_picture="/robogram/gear.png",
)
raise web.seeother("/")
def step2(self):
print("Step2")
self.set_header("Access-Control-Allow-Origin",origin)
self.set_header("Access-Control-Allow-Headers",'Authorization')
self.set_header("Access-Control-Allow-Credentials","true")
print("Step2")
oauth_token = self.get_argument("oauth_token")
oauth_verifier = self.get_argument("oauth_verifier")
print("Step 2: oauth_token: " + oauth_token)
print("Step 2: oauth_verifier: " + oauth_verifier)
global OAUTH_TOKEN
global OAUTH_TOKEN_SECRET
global twitter
twitter = Twython(APP_KEY, APP_SECRET,
OAUTH_TOKEN, OAUTH_TOKEN_SECRET)
final_step = twitter.get_authorized_tokens(oauth_verifier)
OAUTH_TOKEN = final_step['oauth_token']
OAUTH_TOKEN_SECRET = final_step['oauth_token_secret']
print(OAUTH_TOKEN)
twitter = Twython(APP_KEY, APP_SECRET,OAUTH_TOKEN,OAUTH_TOKEN_SECRET)
screen_name = twitter.verify_credentials()["screen_name"]
twitter.update_status(status='Hello!')
self.write(screen_name)
def save_twitter_user():
"""
Save the user received from twitter auth or log them in if already registered
"""
t = Twython(
app_key=CONFIGURATION.TW_OAUTH_KEY,
app_secret=CONFIGURATION.TW_OAUTH_SECRET,
oauth_token=session['request_token']['oauth_token'],
oauth_token_secret=session['request_token']['oauth_token_secret'],
)
authorized_tokens = t.get_authorized_tokens()
try:
user = User.collection.find_one(
{'username': authorized_tokens['screen_name']})
if user:
session['user'] = user
else:
#create a new user via twitter
#oauth = dict(authorized_tokens.items() + dict(provider='twitter').items())
oauth = {
'twitter':
dict(authorized_tokens.items() + dict(auth=True).items())
}
session['user'] = User.create(
username=authorized_tokens['screen_name'], oauth=oauth)
print session['user']
return redirect(url_for('.root'))
except DuplicateKeyError:
#user is trying to reinsert
return 'fail'
def tweet_generated_song(parts, number):
load_dotenv(find_dotenv())
if not (os.environ.get('TWITTER_AUTH_TOKEN')
or os.environ.get('TWITTER_AUTH_SECRET')):
twitter = Twython(os.environ.get('TWITTER_CONSUMER_KEY'),
os.environ.get('TWITTER_CONSUMER_SECRET'))
auth = twitter.get_authentication_tokens()
verifier = input(
'Please visit {} for authorizing your twitter and type the '
'verification code here: '.format(auth['auth_url']))
twitter = Twython(os.environ.get('TWITTER_CONSUMER_KEY'),
os.environ.get('TWITTER_CONSUMER_SECRET'),
auth['oauth_token'], auth['oauth_token_secret'])
final_step = twitter.get_authorized_tokens(verifier)
set_key(find_dotenv(), 'TWITTER_AUTH_TOKEN', final_step['oauth_token'])
set_key(find_dotenv(), 'TWITTER_AUTH_SECRET',
final_step['oauth_token_secret'])
load_dotenv(find_dotenv())
twitter = Twython(os.environ.get('TWITTER_CONSUMER_KEY'),
os.environ.get('TWITTER_CONSUMER_SECRET'),
os.environ.get('TWITTER_AUTH_TOKEN'),
os.environ.get('TWITTER_AUTH_SECRET'))
with open(path('out.mp4'), 'rb') as video:
response = twitter.upload_video(media=video,
media_type='video/mp4',
media_category='tweet_video',
check_progress=True)
twitter.update_status(status=update_header(
'Musikalisches Würfelspiel (K516f) No. #id#', number, parts),
media_ids=[response['media_id_string']])
def authorized(request, redirect_url=settings.AUTHORIZE_COMPLETE_URL):
"""
This function is a callback from Twitter which is triggered after
the user signs in and allows authorization of their Twitter account.
"""
try:
twitter = Twython(
settings.TWITTER_KEY,
settings.TWITTER_SECRET,
request.session['request_token']['oauth_token'],
request.session['request_token']['oauth_token_secret'],
)
# Get the access token to complete the three legged oauth handshake
twitter_info = twitter.get_authorized_tokens(request.GET['oauth_verifier'])
# Something unusual happened from the redirect back from twitter and
# nothing was stored in the session, redirect back to homepage.
except KeyError:
return HttpResponseRedirect(redirect_url)
# only store twitter info in the session if its valid otherwise the user
# hit cancel and didn't actually sign in
if 'oauth_token_secret' in twitter_info and 'user_id' in twitter_info:
request.session['twitter_info'] = twitter_info
return HttpResponseRedirect(redirect_url)
def personalAuthentication():
allKeys = fileToList(TOKEN_FILE)
if len(allKeys[0]) > 4: # we've already saved the personal token
for key in authentication_keys.keys():
# The 4th item of the list of key data will be the key for a
# personal account
authentication_keys[key] = readToken(allKeys, key, 4)
else:
twitter = Twython(authentication_keys['APP_KEY'],
authentication_keys['APP_SECRET'])
auth = twitter.get_authentication_tokens()
import webbrowser
# Open a webpage with your twitter code
webbrowser.open(auth['auth_url'])
try:
auth_pin = input("Please enter the code from twitter: ")
except: # python 2.7
auth_pin = raw_input("Please enter the code from twitter: ")
# These are temporary, part of the overall authentication process
OAUTH_TOKEN = auth['oauth_token']
OAUTH_TOKEN_SECRET = auth['oauth_token_secret']
twitter = Twython(authentication_keys['APP_KEY'],
authentication_keys['APP_SECRET'], OAUTH_TOKEN, OAUTH_TOKEN_SECRET)
final_step = twitter.get_authorized_tokens(auth_pin)
authentication_keys['OAUTH_KEY'] = final_step['oauth_token']
authentication_keys['OAUTH_SECRET'] = final_step['oauth_token_secret']
writeKeys(authentication_keys, TOKEN_FILE)
def twitter_callback(request):
response = HttpResponse()
context = {}
context['not_logged_in'] = False
oauth_verifier = request.GET['oauth_verifier']
twitter = Twython(
os.environ.get('consumer_key'),
os.environ.get('consumer_secret'),
request.session['request_token']['oauth_token'],
request.session['request_token']['oauth_token_secret'],
)
authorized_tokens = twitter.get_authorized_tokens(oauth_verifier)
request.session['oauth_token'] = authorized_tokens['oauth_token']
request.session['oauth_token_secret'] = authorized_tokens['oauth_token_secret']
twitter = Twython(
os.environ.get('consumer_key'),
os.environ.get('consumer_secret'),
request.session['oauth_token'],
request.session['oauth_token_secret'],
)
request.session['screen_name'] = twitter.verify_credentials()['screen_name']
context['user'] = request.session['screen_name']
rendered = render_to_string('webapp/search.html', context)
response.write(rendered)
return response
def auth(request, num="1"):
log = ["auth1"]
OAUTH_VERIFIER = request.GET['oauth_verifier']
twitter = Twython( settings.TWITTER_CONSUMER_KEY,
settings.TWITTER_CONSUMER_SECRET,
request.session['OAUTH_TOKEN'],
request.session['OAUTH_TOKEN_SECRET']
)
final_step = twitter.get_authorized_tokens(OAUTH_VERIFIER)
OAUTH_TOKEN = final_step['oauth_token']
OAUTH_TOKEN_SECERT = final_step['oauth_token_secret']
request.session['OAUTH_TOKEN'] = OAUTH_TOKEN
request.session['OAUTH_TOKEN_SECRET'] = OAUTH_TOKEN_SECERT
request.session['new'] = True
user, created = User.objects.get_or_create(oauth_token=OAUTH_TOKEN, oauth_token_secret=OAUTH_TOKEN_SECERT)
request.session['userid'] = user.id
if OAUTH_TOKEN:
return HttpResponseRedirect("/view")
return render_to_response('auth.html', {'log': log})
def index(request):
if 'oauth_verifier' in request.GET:
#coming back from Twitter.
oauth_verifier = request.GET['oauth_verifier']
t_api = Twython(settings.TWITTER_KEY, settings.TWITTER_SECRET,
request.session['OAUTH_TOKEN'],
request.session['OAUTH_TOKEN_SECRET'])
final_tokens = t_api.get_authorized_tokens(oauth_verifier)
request.session['OAUTH_TOKEN'] = final_tokens['oauth_token']
request.session['OAUTH_TOKEN_SECRET'] = final_tokens[
'oauth_token_secret']
return HttpResponseRedirect("/post")
else:
t_api = Twython(settings.TWITTER_KEY, settings.TWITTER_SECRET)
auth_props = t_api.get_authentication_tokens(
callback_url=settings.TWITTER_CALLBACK)
a_url = auth_props['auth_url']
request.session['OAUTH_TOKEN'] = auth_props['oauth_token']
request.session['OAUTH_TOKEN_SECRET'] = auth_props[
'oauth_token_secret']
return render(request,
'index.html',
locals(),
context_instance=RequestContext(request))
def twitter_thanks(request):
# Now that we've got the magic tokens back from Twitter, we need to exchange
# for permanent ones and store them...
twitter = Twython(
twitter_token = CONSUMER_KEY,
twitter_secret = CONSUMER_SECRET,
oauth_token = request.session['request_token']['oauth_token'],
oauth_token_secret = request.session['request_token']['oauth_token_secret']
)
# Retrieve the tokens we want...
authorized_tokens = twitter.get_authorized_tokens()
# If they already exist, grab them, login and redirect to a page displaying stuff.
try:
user = User.objects.get(username = authorized_tokens['screen_name'])
except User.DoesNotExist:
# We mock a creation here; no email, password is just the token, etc.
user = User.objects.create_user(authorized_tokens['screen_name'], "*****@*****.**", authorized_tokens['oauth_token_secret'])
profile = Profile()
profile.user = user
profile.oauth_token = authorized_tokens['oauth_token']
profile.oauth_secret = authorized_tokens['oauth_token_secret']
profile.save()
user = authenticate(
username = authorized_tokens['screen_name'],
password = authorized_tokens['oauth_token_secret']
)
login(request, user)
return HttpResponseRedirect('/timeline')
def get_oauth_tokens(app_key, app_secret):
"""
Supply `app_key`, `app_secret`
Requires user to signin and confirm oauth1 to create oauth1 tokens
get oauth1 authentication tokens: (`oauth_token`, `oauth_token_secret`)
cf https://twython.readthedocs.io/en/latest/usage/starting_out.html#oauth1
"""
twitter = Twython(app_key, app_secret)
auth = twitter.get_authentication_tokens() #callback_url='oob'
oauth_token = auth['oauth_token']
oauth_token_secret = auth['oauth_token_secret']
twitter = Twython(app_key, app_secret, oauth_token, oauth_token_secret)
oauth_verifier = input(
"1. Sign-in on Twitter.com using URL:\n{auth_url}\n\n2.Enter your pin here:"
.format(auth_url=auth['auth_url']))
final_step = twitter.get_authorized_tokens(oauth_verifier)
final_oauth_token = final_step['oauth_token']
final_oauth_token_secret = final_step['oauth_token_secret']
# Here might wanna store them to DB to avoid user authentication at every run
return (final_oauth_token, final_oauth_token_secret)
def create_tokens(objConfig, app_key, app_secret):
"""
Gets new auth tokens and writes them in 'config.ini' file
"""
twitter = Twython(app_key, app_secret)
auth = twitter.get_authentication_tokens()
OAUTH_TOKEN = auth['oauth_token']
OAUTH_TOKEN_SECRET = auth['oauth_token_secret']
print "To get your PIN number please go to: "
print auth['auth_url']+"\n"
oauth_verifier = raw_input('Please enter your PIN number: ')
twitter = Twython(app_key, app_secret,
OAUTH_TOKEN, OAUTH_TOKEN_SECRET)
final_step = twitter.get_authorized_tokens(oauth_verifier)
OAUTH_TOKEN = final_step['oauth_token']
OAUTH_TOKEN_SECRET = final_step['oauth_token_secret']
try:
twitter = Twython(app_key, app_secret,
OAUTH_TOKEN, OAUTH_TOKEN_SECRET)
user = twitter.verify_credentials()['screen_name']
print "Login successful."
print "Account: "+user
# save oauth_tokens in file
cfgfile = open("tokens.ini",'w')
objConfig.add_section('user')
objConfig.set('user','OAUTH_TOKEN', OAUTH_TOKEN)
objConfig.set('user','OAUTH_TOKEN_SECRET', OAUTH_TOKEN_SECRET)
objConfig.write(cfgfile)
cfgfile.close()
return twitter
except TwythonError as e:
print e
def thanks(request, redirect_url=settings.LOGIN_REDIRECT_URL):
oauth_token = request.session['request_token']['oauth_token']
oauth_token_secret = request.session['request_token']['oauth_token_secret']
twitter = Twython(settings.TWITTER_KEY, settings.TWITTER_SECRET, oauth_token, oauth_token_secret)
authorized_tokens = twitter.get_authorized_tokens(request.GET['oauth_verifier'])
try:
user = User.objects.get(username=authorized_tokens['screen_name'])
except User.DoesNotExist:
user = User.objects.create_user(authorized_tokens['screen_name'], '*****@*****.**',
authorized_tokens['oauth_token_secret'])
profile = TwitterProfile()
profile.user = user
profile.oauth_token = authorized_tokens['oauth_token']
profile.oauth_secret = authorized_tokens['oauth_token_secret']
profile.save()
user = authenticate(
username=authorized_tokens['screen_name'],
password=authorized_tokens['oauth_token_secret']
)
login(request, user)
return HttpResponseRedirect(redirect_url)
def _authorized():
"""
Callback for Twitter authentication.
"""
# Login failed
if request.args.get('denied', None) or request.args.get('oauth_token', '') != session['oauth_token']:
session.pop('oauth_token', None)
session.pop('oauth_token_secret', None)
session.pop('screen_name', None)
return redirect(url_for('index'))
twitter = Twython(
secrets['TWITTER_CONSUMER_KEY'],
secrets['TWITTER_CONSUMER_SECRET'],
session['oauth_token'],
session['oauth_token_secret']
)
auth = twitter.get_authorized_tokens(request.args.get('oauth_verifier'))
session['oauth_token'] = auth['oauth_token']
session['oauth_token_secret'] = auth['oauth_token_secret']
session['screen_name'] = auth['screen_name']
return redirect(url_for('index'))
def add_twitter_token(request, **kwargs):
if request.method == 'GET':
twitter = Twython(
twitter_token = TWITTER_CONSUMER_KEY,
twitter_secret = TWITTER_CONSUMER_SECRET,
oauth_token = request.session['request_token']['oauth_token'],
oauth_token_secret = request.session['request_token']['oauth_token_secret'],
)
oauth_verifier = request.GET['oauth_verifier']
try:
authorized_tokens = twitter.get_authorized_tokens(oauth_verifier)
if 'oauth_token' not in authorized_tokens:
raise TwythonError(authorized_tokens)
oauth_token = authorized_tokens['oauth_token']
oauth_secret = authorized_tokens['oauth_token_secret']
tw = addTwitterToken(token=oauth_token, secret=oauth_secret)
except TwythonError as e:
kwargs['error'] = e
return render_to_response('news/twitter_error.html', kwargs,
context_instance=RequestContext(request))
return render_to_response('news/twitter.html', {},
context_instance=RequestContext(request))
else:
raise Http404
def thanks(request, redirect_url=settings.LOGIN_REDIRECT_URL):
"""A user gets redirected here after hitting Twitter and authorizing your app to use their data.
This is the view that stores the tokens you want
for querying data. Pay attention to this.
"""
# Now that we've got the magic tokens back from Twitter, we need to exchange
# for permanent ones and store them...
oauth_token = request.session['request_token']['oauth_token']
oauth_token_secret = request.session['request_token']['oauth_token_secret']
twitter = Twython(settings.TWITTER_KEY, settings.TWITTER_SECRET,
oauth_token, oauth_token_secret)
# Retrieve the tokens we want...
authorized_tokens = twitter.get_authorized_tokens(request.GET['oauth_verifier'])
# If they already exist, grab them, login and redirect to a page displaying stuff.
try:
user = User.objects.get(username=authorized_tokens['screen_name'])
except User.DoesNotExist:
# We mock a creation here; no email, password is just the token, etc.
user = User.objects.create_user(authorized_tokens['screen_name'], "*****@*****.**", authorized_tokens['oauth_token_secret'])
profile = TwitterProfile()
profile.user = user
profile.oauth_token = authorized_tokens['oauth_token']
profile.oauth_secret = authorized_tokens['oauth_token_secret']
profile.save()
user = authenticate(
username=authorized_tokens['screen_name'],
password=authorized_tokens['oauth_token_secret']
)
login(request, user)
return HttpResponseRedirect(redirect_url)
def authenticate(self, token_file):
""" Authenticate with Twitter and save the OAUTH tokens"""
keys = {}
keys['app_key'] = input('Enter the App Consumer Key: ').strip()
keys['app_secret'] = input('Enter the App Consumer Secret: ').strip()
twitter = Twython(**keys)
auth = twitter.get_authentication_tokens()
keys['oauth_token'] = auth['oauth_token']
keys['oauth_token_secret'] = auth['oauth_token_secret']
auth_url = auth['auth_url']
print(f'\nVisit this url to authorize the application: {auth_url}\n')
oauth_verifier = input('Enter the PIN code: ')
twitter = Twython(**keys)
auth = twitter.get_authorized_tokens(oauth_verifier)
keys['oauth_token'] = auth['oauth_token']
keys['oauth_token_secret'] = auth['oauth_token_secret']
with open(token_file, 'w') as fp:
json.dump(keys, fp)
print(f'The authorized user tokens were saved to {token_file}')
def save_twitter_user():
"""
Save the user received from twitter auth or log them in if already registered
"""
t = Twython(
app_key=CONFIGURATION.TW_OAUTH_KEY,
app_secret=CONFIGURATION.TW_OAUTH_SECRET,
oauth_token=session["request_token"]["oauth_token"],
oauth_token_secret=session["request_token"]["oauth_token_secret"],
)
authorized_tokens = t.get_authorized_tokens()
try:
user = User.collection.find_one({"username": authorized_tokens["screen_name"]})
if user:
session["user"] = user
else:
# create a new user via twitter
# oauth = dict(authorized_tokens.items() + dict(provider='twitter').items())
oauth = {"twitter": dict(authorized_tokens.items() + dict(auth=True).items())}
session["user"] = User.create(username=authorized_tokens["screen_name"], oauth=oauth)
print session["user"]
return redirect(url_for(".root"))
except DuplicateKeyError:
# user is trying to reinsert
return "fail"
def getAuthTokens():
f_authTokens = open(config.FILE_TMP_TOKENS, 'w')
# get first auth
twitter = Twython(config.APP_KEY, config.APP_SECRET)
firstAuth = twitter.get_authentication_tokens()
# get auth pin
print 'auth url: ' + firstAuth['auth_url']
authPin = getpass('pin: ')
# get second auth
twitter = Twython(
config.APP_KEY,
config.APP_SECRET,
firstAuth['oauth_token'],
firstAuth['oauth_token_secret'])
secondAuth = twitter.get_authorized_tokens(authPin)
# save tokens to a file
for key in secondAuth:
line = key + '\t' + secondAuth[key] + '\n'
f_authTokens.write(line)
f_authTokens.close()
return secondAuth
def step2(self):
print("Step2")
self.set_header("Access-Control-Allow-Origin", origin)
self.set_header("Access-Control-Allow-Headers", 'Authorization')
self.set_header("Access-Control-Allow-Credentials", "true")
print("Step2")
oauth_token = self.get_argument("oauth_token")
oauth_verifier = self.get_argument("oauth_verifier")
print("Step 2: oauth_token: " + oauth_token)
print("Step 2: oauth_verifier: " + oauth_verifier)
global OAUTH_TOKEN
global OAUTH_TOKEN_SECRET
global twitter
twitter = Twython(APP_KEY, APP_SECRET, OAUTH_TOKEN, OAUTH_TOKEN_SECRET)
final_step = twitter.get_authorized_tokens(oauth_verifier)
OAUTH_TOKEN = final_step['oauth_token']
OAUTH_TOKEN_SECRET = final_step['oauth_token_secret']
print(OAUTH_TOKEN)
twitter = Twython(APP_KEY, APP_SECRET, OAUTH_TOKEN, OAUTH_TOKEN_SECRET)
screen_name = twitter.verify_credentials()["screen_name"]
twitter.update_status(status='Hello!')
self.write(screen_name)
def callback(Rate_id):
""" twitter로부터 callback url이 요청되었을때
최종인증을 한 후 트위터로 해당 사진과 커멘트를 전송한다.
"""
Log.info("callback oauth_token:" + request.args['oauth_token']);
Log.info("callback oauth_verifier:" + request.args['oauth_verifier']);
# oauth에서 twiter로 부터 넘겨받은 인증토큰을 세션으로 부터 가져온다.
OAUTH_TOKEN = session['OAUTH_TOKEN']
OAUTH_TOKEN_SECRET = session['OAUTH_TOKEN_SECRET']
oauth_verifier = request.args['oauth_verifier']
try:
# 임시로 받은 인증토큰을 이용하여 twitter 객체를 만들고 인증토큰을 검증한다.
twitter = Twython(current_app.config['TWIT_APP_KEY'],
current_app.config['TWIT_APP_SECRET'],
OAUTH_TOKEN, OAUTH_TOKEN_SECRET)
final_step = twitter.get_authorized_tokens(oauth_verifier)
# oauth_verifier를 통해 얻은 최종 인증토큰을 이용하여 twitter 객체를 새로 생성한다.
twitter = Twython(current_app.config['TWIT_APP_KEY'],
current_app.config['TWIT_APP_SECRET'],
final_step['oauth_token'],
final_step['oauth_token_secret'])
session['TWITTER'] = twitter
# 파라미터로 받은 Rate_id를 이용하여 해당 사진과 커멘트를 트위터로 전송한다.
__send_twit(twitter, Rate_id)
except TwythonError as e:
Log.error("callback(): TwythonError , "+ str(e))
session['TWITTER_RESULT'] = str(e)
return redirect(url_for('.show_all'))
def twitter_autenticacao():
resultado = None
id = ''
verifier = request.args.get('oauth_verifier', None)
token_oauth = session.get('token', None)
token_secret_oauth = session.get('token_secret', None)
twitter = Twython(APP_KEY, APP_SECRET, token_oauth, token_secret_oauth)
final_step = twitter.get_authorized_tokens(verifier)
OAUTH_TOKEN = str(final_step['oauth_token'])
OAUTH_TOKEN_SECRET = str(final_step['oauth_token_secret'])
if session.get('funcao', None) == 'cadastrar':
resultado = db_cadastro('', 'cadastrar', 'twitter', OAUTH_TOKEN,
OAUTH_TOKEN_SECRET, '')
elif session.get('funcao', None) == 'login':
resultado = db_login('twitter', OAUTH_TOKEN, OAUTH_TOKEN_SECRET)
elif session.get('funcao', None) == 'tweet':
resultado = db_cadastro(str(session.get('id_usuario',
None)), 'inserir', 'twitter',
OAUTH_TOKEN, OAUTH_TOKEN_SECRET, '')
j = json.loads(resultado)
if j['status'] == 'Success':
id = str(j['id'])
return redirect('http://kanoon.mybluemix.net/?id=' + str(id))
def twitter_login_callback(self, request=None, **kwargs):
'''
when we have the oauth verifier then send it through this api
'''
#get the params twitter need
post = simplejson.loads(request.body)
twitter_key = settings.TWITTER_KEY
twitter_secret = settings.TWITTER_SECRET
oauth_token = request.session.get('OAUTH_TOKEN', '')
oauth_token_secret = request.session.get('OAUTH_TOKEN_SECRET', '')
oauth_verifier = post.get('oauth_verifier', '')
#get the params from the login
twitter = Twython(twitter_key, twitter_secret,oauth_token, oauth_token_secret)
final_step = twitter.get_authorized_tokens(oauth_verifier)
user_oauth_token = final_step['oauth_token']
user_oauth_token_secret = final_step['oauth_token_secret']
#find existing user or create a new one
try:
userprofile = UserProfile.objects.get(twitter_oauth_token=user_oauth_token, twitter_oauth_token_secret=user_oauth_token_secret)
user = userprofile.user
except:
#create a user and user profile
api_key = ApiKey()
username = api_key.generate_key()[0:30]
password = api_key.generate_key()[0:30]
user = User()
user.username = username
user.is_active = True
user.password = password
user.save()
userprofile = user.profile
userprofile.twitter_oauth_token = user_oauth_token
userprofile.twitter_oauth_token_secret = user_oauth_token_secret
userprofile.save()
#delete all the old api keys
api_keys = ApiKey.objects.filter(user=user)
api_keys.delete()
#create a new api key
api_key, created = ApiKey.objects.get_or_create(user=user)
api_key.save()
#store the keys in the session
request.session['api_key'] = api_key.key
request.session['username'] = user.username
ur = UserProfileResource()
ur_bundle = ur.build_bundle(obj=user.profile, request=request)
return self.create_response(request, {
'is_logged_in': True,
'message': 'The user is logged in',
'username': user.username,
'api_key': api_key.key,
'user_profile': json.loads(ur.serialize(None, ur.full_dehydrate(ur_bundle), 'application/json'))
})
def get(self, request, *args, **kwargs):
if not request.GET.get("oauth_token"):
twitter = Twython(settings.TWITTER_KEY, settings.TWITTER_SECRET)
# Request an authorization url to send the user to...
callback_url = request.build_absolute_uri(
reverse('cms_login_twitter'))
auth_props = twitter.get_authentication_tokens(callback_url)
# Then send them over there, durh.
request.session['request_token'] = auth_props
return HttpResponseRedirect(auth_props['auth_url'])
else:
try:
oauth_token = request.session['request_token']['oauth_token']
oauth_token_secret = request.session['request_token'][
'oauth_token_secret']
twitter = Twython(settings.TWITTER_KEY,
settings.TWITTER_SECRET, oauth_token,
oauth_token_secret)
# Retrieve the tokens we want...
authorized_tokens = twitter.get_authorized_tokens(
request.GET['oauth_verifier'])
twitter = Twython(settings.TWITTER_KEY,
settings.TWITTER_SECRET,
authorized_tokens['oauth_token'],
authorized_tokens['oauth_token_secret'])
user_data = twitter.verify_credentials()
membro = None
if Membro.objects.filter(
twitter_id=authorized_tokens.get('user_id')).exists():
membro = Membro.objects.filter(
twitter_id=authorized_tokens.get('user_id')).latest(
'pk')
# Atualiza o Membro
membro.twitter_oauth_token = authorized_tokens.get(
'oauth_token')
membro.twitter_oauth_token_secret = authorized_tokens.get(
'oauth_token_secret')
membro.save()
elif Membro.objects.filter(
nome=user_data.get('name')).exists():
membro = Membro.objects.filter(
nome=user_data.get('name')).latest('pk')
# Atualiza o Membro
membro.twitter_id = authorized_tokens.get('user_id')
membro.twitter_oauth_token = authorized_tokens.get(
'oauth_token')
membro.twitter_oauth_token_secret = authorized_tokens.get(
'oauth_token_secret')
membro.save()
login_next(request, membro)
except:
messages.info(request, u'Erro na conexão com o Twitter.')
return HttpResponseRedirect(reverse('cms_login'))
def login(request):
if request.GET.get('denied'):
return redirect(request.GET.get('redir_to', '') or '/')
if request.GET.get('oauth_verifier'):
temp_token = request.session['oauth_token']
twitter_token = request.GET.get('oauth_token')
if temp_token != twitter_token:
return HttpResponseForbidden()
oauth_verifier = request.GET['oauth_verifier']
twitter = Twython(
settings.TWITTER_APP_KEY,
settings.TWITTER_APP_SECRET,
request.session['oauth_token'],
request.session['oauth_token_secret']
)
final_auth = twitter.get_authorized_tokens(oauth_verifier)
profile, new = TwitterProfile.objects.get_or_create(
OAUTH_TOKEN=final_auth['oauth_token'], # final token
OAUTH_TOKEN_SECRET=final_auth['oauth_token_secret'], # final token
)
# if we updated the tokens, must refresh the instance
try:
profile.user
except:
profile = TwitterProfile.objects.get(OAUTH_TOKEN=final_auth['oauth_token'])
profile.user.backend = 'django.contrib.auth.backends.ModelBackend'
django_login(request, profile.user)
if new and settings.__dict__['_wrapped'].__dict__.get(
'TWITTER_NEW_USER_URL', False
):
return redirect(
settings.TWITTER_NEW_USER_URL +
"?redir_to=" + request.GET.get('redir_to', '')
)
else:
return redirect(request.GET.get('redir_to', '') or '/')
twitter = Twython(
settings.TWITTER_APP_KEY,
settings.TWITTER_APP_SECRET,
)
callback_url = (
settings.HOST +
reverse('django_twitter_auth:login') +
"?redir_to=" + request.META.get('HTTP_REFERER', '')
)
auth = twitter.get_authentication_tokens(
callback_url=callback_url
)
request.session['oauth_token'] = auth['oauth_token']
request.session['oauth_token_secret'] = auth['oauth_token_secret']
return redirect(auth['auth_url'])
def get_verification(): global OAUTH_TOKEN global OAUTH_TOKEN_SECRET twitter = Twython(APP_KEY, APP_SECRET,OAUTH_TOKEN, OAUTH_TOKEN_SECRET) final_step = twitter.get_authorized_tokens(request.args['oauth_verifier']) OAUTH_TOKEN2 = final_step['oauth_token'] OAUTH_TOKEN_SECRET2 = final_step['oauth_token_secret'] return 'OK!</br> OAUTH TOKEN:' + OAUTH_TOKEN2 +'</br> OAUTH TOKEN SECRET: '+ OAUTH_TOKEN_SECRET2
def final_verify(oauth_verifier, auth):
twitter = Twython(consumer_key, consumer_secret, auth['oauth_token'], auth['oauth_token_secret'])
try:
final_step = twitter.get_authorized_tokens(oauth_verifier)
return final_step
except TwythonError as e:
print(e.error_code)
return False
def _exchange_code_for_token(self, auth_code):
t = Twython(app_key=self.client_key[0], app_secret=self.client_key[1],
oauth_token=self.oauth_token, oauth_token_secret=self.oauth_token_secret)
tokens = t.get_authorized_tokens(auth_code)
try:
return (tokens["oauth_token"], tokens["oauth_token_secret"])
except KeyError as e:
raise IncorrectAuthCodeError(e)
def oauth_tw(request):
from twython import Twython
s = session(request)
if not 'twitter/auth' in s: raise Exception('Twitter Auth Redirect Error')
tok = s['twitter/auth']
oauth_verifier = request.GET['oauth_verifier']
tw = settings.oauth_tw
twitter = Twython(tw['id'], tw['key'], tok['key'], tok['secret'])
fs = twitter.get_authorized_tokens(oauth_verifier)
if 'error' in request.GET:
return 'Authorisation Error' + request.GET['error_description']
user_id = 'user:tw:' + fs['user_id']
user = request.db.doc.find_one({'_id': user_id})
if user and 'ban' in user['doc'] and user['doc']['ban'] == 'true':
session_add_mess('Error logging in')
redirect('/')
return ''
s['user_id'] = 'tw:' + fs['user_id']
s.save()
if not user:
user = {
'_id': user_id,
"alien": "tw",
'name': fs['screen_name'],
'password': "******",
"type": "table_row",
"doc_type": "des:users",
"doc": {
"user": user_id,
"old": "",
"phone": "",
"address": "",
"mail": "",
'rate': 0,
'date': create_date(),
"home": "false",
'name': {
'ru': fs['screen_name']
}
}
}
request.db.doc.save(user)
request.db.doc.update({'_id': 'role:simple_users'},
{'$set': {
'users.' + user_id: 'true'
}})
user = request.db.doc.find_one({'_id': user_id})
user['doc']['name'] = {cur_lang(): fs['screen_name']}
from libs.files.files import link_upload_post_
request.db.doc.save(user)
session_add_mess(u'You have successfully logged in')
redirect('/')
def authWithPin(self, APP_KEY, APP_SECRET, OAUTH_TOKEN, OAUTH_TOKEN_SECRET,
pin):
twitter = Twython(APP_KEY, APP_SECRET, OAUTH_TOKEN, OAUTH_TOKEN_SECRET)
auth = twitter.get_authorized_tokens(pin)
OAUTH_TOKEN = auth['oauth_token']
OAUTH_TOKEN_SECRET = auth['oauth_token_secret']
return OAUTH_TOKEN, OAUTH_TOKEN_SECRET
def login(oauth_token, oauth_token_secret, oauth_verifier):
twitter = Twython(keys.CONSUMER_KEY,
keys.CONSUMER_SECRET,
oauth_token,
oauth_token_secret)
final_step = twitter.get_authorized_tokens(oauth_verifier)
oauth_token = final_step['oauth_token']
oauth_token_secret = final_step['oauth_token_secret']
return oauth_token, oauth_token_secret
def twitter_callback(request, redirect_url='/private'):
try:
oauth_verifier = request.GET['oauth_verifier']
except:
return HttpResponseRedirect('/')
twitter_token = Config.objects.all().latest('id').twitter_key
twitter_secret = Config.objects.all().latest('id').twitter_secret
oauth_token = request.session['request_token']['oauth_token']
oauth_token_secret = request.session['request_token']['oauth_token_secret']
twitter = Twython(twitter_token,twitter_secret,oauth_token,oauth_token_secret)
authorized_tokens = twitter.get_authorized_tokens(oauth_verifier)
print authorized_tokens
try:
profile = TwitterProfile.objects.get(tw_user_id=authorized_tokens['user_id'])
user = User.objects.get(pk=profile.user_id)
user.backend = 'django.contrib.auth.backends.ModelBackend'
oauth_token = authorized_tokens['oauth_token']
oauth_token_secret = authorized_tokens['oauth_token_secret']
if user.is_active:
tw_profile = TwitterProfile.objects.all().filter(screen_name=authorized_tokens['screen_name'])
tw_profile.update(oauth_token=oauth_token,oauth_secret=oauth_token_secret)
login(request, user)
return HttpResponseRedirect('/dashboard/')
else:
# failed back to login
return HttpResponseRedirect('/')
except Exception as error: #TwitterProfile.DoesNotExist
print error
user_id = authorized_tokens['user_id']
screen_name = authorized_tokens['screen_name']
oauth_token = authorized_tokens['oauth_token']
oauth_token_secret = authorized_tokens['oauth_token_secret']
user = User.objects.create_user(user_id,'',oauth_token_secret)
user = authenticate(username=user_id, password=oauth_token_secret)
login(request, user)
user_obj = User.objects.all().filter(username=user_id).get()
# Add to TwitterProfile
profile = TwitterProfile(user=user_obj,oauth_token=oauth_token,oauth_secret=oauth_token_secret,screen_name=screen_name,tw_user_id=user_id)
profile.save()
return HttpResponseRedirect('/finish-signup/')
return HttpResponseRedirect('/dashboard/')
def statistics_authentication_twitterv01_oauth(request):
controller = TwitterV01AuthenticationController.GetOrCreate()
template_data = {'errors': [], 'controller': controller}
app_key = [e for e in controller.config['elements'] if e['name'] == 'app_key'][0]['value']
app_secret = [e for e in controller.config['elements'] if e['name'] == 'app_secret'][0]['value']
# auth = tweepy.OAuthHandler(str(app_key), str(app_secret))
if 'pin' in request.POST:
token = request.session.get('request_token', '')
auth = Twython(app_key, app_secret, token[0], token[1])
# auth.set_request_token(token[0], token[1])
try:
# auth.get_access_token(request.POST.get('pin'))
auth_tokens = auth.get_authorized_tokens(request.POST.get('pin'))
for element in controller.config['elements']:
if element['name'] == 'oauth_token':
# element['value'] = auth.access_token.key
element['value'] = auth_tokens.get('oauth_token')
if element['name'] == 'oauth_secret':
# element['value'] = auth.access_token.secret
element['value'] = auth_tokens.get('oauth_token_secret')
controller.save()
request.session.pop('request_token', '')
return_data = {
'template': render_to_string(
'django_odc/modals/configure_twitterv01_authentication/twitterv01_authentication_confirm.html'),
'status': 'ok'}
return HttpResponse(json.dumps(return_data), content_type='application/json')
except Exception:
template_data['errors'].append(
'There was an error using the PIN you supplied, please try authorising again.')
else:
auth = Twython(app_key, app_secret)
try:
# redirect_url = auth.get_authorization_url()
auth_props = auth.get_authentication_tokens()
# request.session['request_token'] = (auth.request_token.key, auth.request_token.secret)
request.session['request_token'] = (auth_props.get('oauth_token'), auth_props.get('oauth_token_secret'))
template_data['redirect_url'] = auth_props.get('auth_url')
# except tweepy.TweepError:
except Exception:
template_data['errors'].append(
'There was a problem with the details you supplied, it could be that twitter is down but please '
'check the application key and secret and try again.')
return_data = {
'status': 'error',
'template': render_to_string(
'django_odc/modals/configure_twitterv01_authentication/twitterv01_authentication_config.html',
template_data,
context_instance=RequestContext(request))}
return HttpResponse(json.dumps(return_data), content_type='application/json')
template = render_to_string(
'django_odc/modals/configure_twitterv01_authentication/twitterv01_authentication_oauth.html',
template_data,
context_instance=RequestContext(request))
return_data = {'status': 'ok' if not template_data['errors'] else 'error', 'template': template}
return HttpResponse(json.dumps(return_data), content_type='application/json')
def recordToken(self, user_name, verifier):
tuser = TwitterUser.objects.get(user_name=user_name)
twython = Twython(self.appObj.consumer_key, self.appObj.consumer_secret, tuser.cauth, tuser.cauth_secret)
final_step = twython.get_authorized_tokens(verifier)
tuser.cauth = tuser.cauth_secret = ""
tuser.auth = final_step['oauth_token']
tuser.auth_secret = final_step['oauth_token_secret']
tuser.save()
