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