def test_context_local(): responses.add(responses.GET, "https://google.com") # set up two apps with two different set of auth tokens app1 = Flask(__name__) tbp1 = make_twitter_blueprint("foo1", "bar1", redirect_to="url1") app1.register_blueprint(tbp1) #tbp1.session.auth.client.get_oauth_signature = mock.Mock(return_value="sig1") app2 = Flask(__name__) tbp2 = make_twitter_blueprint("foo2", "bar2", redirect_to="url2") app2.register_blueprint(tbp2) #tbp2.session.auth.client.get_oauth_signature = mock.Mock(return_value="sig2") # outside of a request context, referencing functions on the `twitter` object # will raise an exception with pytest.raises(RuntimeError): twitter.get("https://google.com") # inside of a request context, `twitter` should be a proxy to the correct # blueprint session with app1.test_request_context("/"): tbp1.session.auth.client.get_oauth_signature = mock.Mock( return_value="sig1") tbp2.session.auth.client.get_oauth_signature = mock.Mock( return_value="sig2") app1.preprocess_request() twitter.get("https://google.com") auth_header = dict( parse_authorization_header( responses.calls[0].request.headers['Authorization'].decode( 'utf-8'))) assert auth_header["oauth_consumer_key"] == "foo1" assert auth_header["oauth_signature"] == "sig1" with app2.test_request_context("/"): tbp1.session.auth.client.get_oauth_signature = mock.Mock( return_value="sig1") tbp2.session.auth.client.get_oauth_signature = mock.Mock( return_value="sig2") app2.preprocess_request() twitter.get("https://google.com") auth_header = dict( parse_authorization_header( responses.calls[1].request.headers['Authorization'].decode( 'utf-8'))) assert auth_header["oauth_consumer_key"] == "foo2" assert auth_header["oauth_signature"] == "sig2"
def create_app(): app = Flask(__name__) # already have app.config["SQLALCHEMY_DATABASE_URI"] = DATABASE_URL app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False # for login from flask dance app.config['SECRET_KEY'] = 'thisissupposedtobeasecret' app.config["TWITTER_OAUTH_CLIENT_KEY"] = TWITTER_API_KEY app.config["TWITTER_OAUTH_CLIENT_SECRET"] = TWITTER_API_SECRET twitter_bp = make_twitter_blueprint() app.register_blueprint(twitter_bp, url_prefix="/login") # for databases db.init_app(app) migrate.init_app(app, db) # linking to routes.py page via my_routes variable app.register_blueprint(my_routes) return app
def create_app(config_name): app = Flask(__name__) # Creating the app configurations. app.config.from_object(config_options[config_name]) # Intitializing flask extensions bootstrap.init_app(app) db.init_app(app) login_manager.init_app(app) moment.init_app(app) login_manager.session_protection = 'strong' login_manager.login_view = 'auth.login' # configure upload setUp configure_uploads(app, photos) mail.init_app(app) # Registering the blueprint from .main import main as main_blueprint app.register_blueprint(main_blueprint) from .auth import auth as auth_blueprint app.register_blueprint(auth_blueprint, url_prefix='/authenticate') twitter_blueprint = make_twitter_blueprint(api_key="AQiZnAVb1NlnMJooyIYonMiO8",api_secret="l08BAtgpJjOnblfJYxOK5gip2XSbQCNhsg7vNj9zcgmdLg2t3J") app.register_blueprint(twitter_blueprint, url_prefix="/login") return app
def test_context_local(): responses.add(responses.GET, "https://google.com") # set up two apps with two different set of auth tokens app1 = Flask(__name__) tbp1 = make_twitter_blueprint("foo1", "bar1", redirect_to="url1") app1.register_blueprint(tbp1) app2 = Flask(__name__) tbp2 = make_twitter_blueprint("foo2", "bar2", redirect_to="url2") app2.register_blueprint(tbp2) # outside of a request context, referencing functions on the `twitter` object # will raise an exception with pytest.raises(RuntimeError): twitter.get("https://google.com") # inside of a request context, `twitter` should be a proxy to the correct # blueprint session with app1.test_request_context("/"): tbp1.session.auth.client.get_oauth_signature = mock.Mock(return_value="sig1") tbp2.session.auth.client.get_oauth_signature = mock.Mock(return_value="sig2") app1.preprocess_request() twitter.get("https://google.com") auth_header = dict( parse_authorization_header( responses.calls[0].request.headers["Authorization"].decode("utf-8") ) ) assert auth_header["oauth_consumer_key"] == "foo1" assert auth_header["oauth_signature"] == "sig1" with app2.test_request_context("/"): tbp1.session.auth.client.get_oauth_signature = mock.Mock(return_value="sig1") tbp2.session.auth.client.get_oauth_signature = mock.Mock(return_value="sig2") app2.preprocess_request() twitter.get("https://google.com") auth_header = dict( parse_authorization_header( responses.calls[1].request.headers["Authorization"].decode("utf-8") ) ) assert auth_header["oauth_consumer_key"] == "foo2" assert auth_header["oauth_signature"] == "sig2"
def test_blueprint_factory(): twitter_bp = make_twitter_blueprint( api_key="foobar", api_secret="supersecret", redirect_to="index" ) assert isinstance(twitter_bp, OAuth1ConsumerBlueprint) assert twitter_bp.session.base_url == "https://api.twitter.com/1.1/" assert twitter_bp.session.auth.client.client_key == "foobar" assert twitter_bp.session.auth.client.client_secret == "supersecret" assert twitter_bp.request_token_url == "https://api.twitter.com/oauth/request_token" assert twitter_bp.access_token_url == "https://api.twitter.com/oauth/access_token" assert twitter_bp.authorization_url == "https://api.twitter.com/oauth/authorize"
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) config[config_name].init_app(app) app.logger.info('FLASK_CONFIG %s', os.getenv('FLASK_CONFIG')) app.logger.info('FLASK_DEBUG %s', os.getenv('FLASK_DEBUG')) stripe_mode = 'LIVE!!' if app.config['STRIPE_LIVE'] == '1' else 'TEST' app.logger.info('@@@ Stripe mode @@@ is %s', stripe_mode) app.jinja_env.globals.update(len=len) bootstrap.init_app(app) db.init_app(app) login_manager.init_app(app) if app.config['SSL_REDIRECT']: from flask_sslify import SSLify sslify = SSLify(app) from .main import main as main_blueprint app.register_blueprint(main_blueprint) # google google_blueprint = make_google_blueprint( scope=[ "https://www.googleapis.com/auth/userinfo.email", "https://www.googleapis.com/auth/userinfo.profile", "openid", ], client_id=app.config['GOOGLE_CLIENT_ID'], client_secret=app.config['GOOGLE_CLIENT_SECRET'], ) app.register_blueprint(google_blueprint, url_prefix="/login") # twitter twitter_blueprint = make_twitter_blueprint( api_key=app.config['TWITTER_API_KEY'], api_secret=app.config['TWITTER_API_SECRET'], ) app.register_blueprint(twitter_blueprint, url_prefix="/login") # app.logger.info('url_map= %s', app.url_map) # app.logger.info('config= %s', app.config) return app
def create_module(app, **kwargs): bcrypt.init_app(app) oid.init_app(app) login_manager.init_app(app) jwt.init_app(app) twitter_blueprint = make_twitter_blueprint( api_key=app.config.get("TWITTER_API_KEY"), api_secret=app.config.get("TWITTER_API_SECRET")) app.register_blueprint(twitter_blueprint, url_prefix="/auth/login") facebook_blueprint = make_facebook_blueprint( client_id=app.config.get("FACEBOOK_CLIENT_ID"), client_secret=app.config.get("FACEBOOK_CLIENT_SECRET")) app.register_blueprint(facebook_blueprint, url_prefix="/auth/login") from .controllers import auth_blueprint app.register_blueprint(auth_blueprint)
def test_load_from_config(): responses.add( responses.POST, "https://api.twitter.com/oauth/request_token", body="oauth_token=faketoken&oauth_token_secret=fakesecret", ) app = Flask(__name__) app.secret_key = "anything" app.config["TWITTER_OAUTH_API_KEY"] = "foo" app.config["TWITTER_OAUTH_API_SECRET"] = "bar" twitter_bp = make_twitter_blueprint(redirect_to="index") app.register_blueprint(twitter_bp) app.test_client().get("/twitter") auth_header = dict(parse_authorization_header( responses.calls[0].request.headers['Authorization'].decode('utf-8') )) assert auth_header["oauth_consumer_key"] == "foo"
def test_load_from_config(): responses.add( responses.POST, "https://api.twitter.com/oauth/request_token", body="oauth_token=faketoken&oauth_token_secret=fakesecret", ) app = Flask(__name__) app.secret_key = "anything" app.config["TWITTER_OAUTH_API_KEY"] = "foo" app.config["TWITTER_OAUTH_API_SECRET"] = "bar" twitter_bp = make_twitter_blueprint(redirect_to="index") app.register_blueprint(twitter_bp) app.test_client().get("/twitter") auth_header = dict( parse_authorization_header( responses.calls[0].request.headers['Authorization'].decode( 'utf-8'))) assert auth_header["oauth_consumer_key"] == "foo"
login_required from flask_dance.contrib.facebook import make_facebook_blueprint, facebook from flask_dance.contrib.google import make_google_blueprint, google from flask_dance.contrib.twitter import make_twitter_blueprint, twitter from my_app import db, login_manager, get_ldap_connection from my_app.auth.models import User, RegistrationForm, LoginForm auth = Blueprint('auth', __name__) facebook_blueprint = make_facebook_blueprint(scope='email', redirect_to='auth.facebook_login') google_blueprint = make_google_blueprint(scope=[ "openid", "https://www.googleapis.com/auth/userinfo.email", "https://www.googleapis.com/auth/userinfo.profile" ], redirect_to='auth.google_login') twitter_blueprint = make_twitter_blueprint(redirect_to='auth.twitter_login') @auth.route("/ldap-login", methods=['GET', 'POST']) def ldap_login(): if current_user.is_authenticated: flash('Your are already logged in.', 'info') return redirect(url_for('auth.home')) form = LoginForm() if form.validate_on_submit(): username = request.form.get('username') password = request.form.get('password') try: conn = get_ldap_connection()
from flask import render_template, Blueprint, redirect, url_for, flash, abort, session from flask_dance.contrib.twitter import make_twitter_blueprint, twitter from flask_dance.contrib.google import make_google_blueprint, google from flask_dance.consumer.storage.sqla import SQLAlchemyStorage from flask_dance.consumer import oauth_authorized from os import environ, path from sqlalchemy.orm.exc import NoResultFound from flask_login import login_user oauth_blueprint = Blueprint('oauth_blueprint', __name__, template_folder='templates', static_folder='static') twitter_blueprint = make_twitter_blueprint( api_key=environ.get('TWITTER_API_KEY'), api_secret=environ.get('TWITTER_SECRET')) google_blueprint = make_google_blueprint( client_id=environ.get('GOOGLE_CLIENT_ID'), client_secret=environ.get('GOOGLE_SECRET')) @oauth_blueprint.route('/twitter') def twitter_login(): if not twitter.authorized: return redirect(url_for('twitter.login')) account_info = twitter.get('account/settings.json') account_info_json = account_info.json() screen_name = account_info_json['discoverable_by_email'] print(f'{account_info_json}') print(f'{screen_name}')
from flask import Flask, redirect, url_for, render_template from flask_dance.contrib.twitter import make_twitter_blueprint, twitter from api import get_entry import time app = Flask(__name__) app.secret_key = "supersecret" blueprint = make_twitter_blueprint( api_key="GNTPJ8alh2T4wC6396QB1qLao", api_secret="5mGnp5fHYea9nf57aiPhOR04wD1oUOJSAsP9rcYQCD2KilvPJn", ) app.register_blueprint(blueprint, url_prefix="/login") @app.route("/") def index(): if not twitter.authorized: return redirect(url_for("twitter.login")) resp = twitter.get("account/settings.json") stream_entries = get_stream() return render_template("index.html", entries=stream_entries) @app.route("/logout") def logout(): return redirect(url_for("twitter.login")) @app.route("/twitter") def twitter_profile():
from flask_dance.contrib.twitter import make_twitter_blueprint, twitter from flask_dance.contrib.github import make_github_blueprint, github import os app = Flask(__name__) app.config[ 'SQLALCHEMY_DATABASE_URI'] = 'postgresql://*****:*****@localhost/projectdb' app.config['SECRET_KEY'] = 'thisisasecretkey' # Source: https://stackoverflow.com/questions/27785375/testing-flask-oauthlib-locally-without-https # for github HTTPS os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1' twitter_blueprint = make_twitter_blueprint( api_key='snajatcEGgC19dwf9AFNQMtM8 ', api_secret='ieX5hO4amP6ay6bkPCyY1Bfla9BtWMla7NWRN9nyzu4tDdVKR4') github_blueprint = make_github_blueprint( client_id='b1198cf45b0983ee621f', client_secret='80ad32fdf60fc3350e398da866e77891075d15b4') app.register_blueprint(twitter_blueprint, url_prefix='/twitter_login') app.register_blueprint(github_blueprint, url_prefix='/github_login') db = SQLAlchemy(app) employee_id = '1' class Employee_details(db.Model): __tablename__ = 'emp_employee'
from flask_sqlalchemy import SQLAlchemy from flask_bcrypt import Bcrypt from flask_login import LoginManager from flask_mail import Mail from spliit.config import Config from flask_dance.contrib.twitter import make_twitter_blueprint db = SQLAlchemy() bcrypt = Bcrypt() loginManager = LoginManager() loginManager.login_view = 'main.home' loginManager.login_message_category = 'info' mail = Mail() oauth = OAuth() twitter_blueprint = make_twitter_blueprint( api_key='HkXw4wMJqkMW1ooBlDnONzOCq', api_secret='ceF37WAVEiMbjooVbiqI4LjsalNY01ANUeEziVG5pXIlfM4lW4') facebook = oauth.register( name='facebook', base_url='https://graph.facebook.com/', request_token_url=None, access_token_url='/oauth/access_token', authorize_url='https://www.facebook.com/dialog/oauth', consumer_key="316037422989105", consumer_secret="e813ef662626a2a7469fd9bc5c82d024", request_token_params={'scope': 'email'}) def create_app(config_class=Config): app = Flask(__name__)
from flask import Flask, render_template, request, session, url_for, redirect, jsonify from flask_dance.contrib.twitter import make_twitter_blueprint, twitter from werkzeug.contrib.fixers import ProxyFix import requests, psycopg2 blitzkrieg = Flask(__name__) blitzkrieg.wsgi_app = ProxyFix(blitzkrieg.wsgi_app) from routes import login_views from routes import ping_views from routes import static_website_views conn = psycopg2.connect("dbname='dep0rlstv76jac' password='******' user='******' host='ec2-107-21-219-235.compute-1.amazonaws.com' port='5432'"); #conn = psycopg2.connect("dbname='blitzkrieg' user='******' host='localhost' port='5432'"); conn.autocommit = True blitzkrieg.db = conn blitzkrieg.secret_key = 'i\x0b\x8d\r\xc2\xa83\x1dD8\x10_\xb8Q\x87\xce@\xf1k\xd6\x14\xa1\xffP' blueprint = make_twitter_blueprint( api_key="3ZqiKnPeVwcNf6Z5TNYTK3Dj6", api_secret="lR8qWwj1orhFP2HCyyyl2KTI4uso3MmhxzonKvYQ6TKvwDfF5H", redirect_url="twitter_redirect" ) blitzkrieg.register_blueprint(blueprint, url_prefix="/login")
class OAuth(OAuthConsumerMixin, db.Model): provider_user_id = db.Column(db.String(256), unique=True, nullable=False) user_id = db.Column(db.Integer, db.ForeignKey(User.id), nullable=False) user = db.relationship(User) login_manager = LoginManager() login_manager.login_view = 'twitter.login' login_manager.blueprint_login_views = 'index' @login_manager.user_loader def load_user(user_id): return User.query.get(int(user_id)) blueprint = make_twitter_blueprint( storage=SQLAlchemyStorage(OAuth, db.session, user=current_user) ) # create/login local user on successful OAuth login @oauth_authorized.connect_via(blueprint) def twitter_logged_in(blueprint, token): if not token: #flash("Failed to log in.", category="error") return False resp = blueprint.session.get("account/verify_credentials.json") if not resp.ok: msg = "Failed to fetch user info." #flash(msg, category="error") return False
from flask_login import (current_user, login_required, login_user, logout_user) from app_folder import app, db from . import models users_blueprint = Blueprint('auth', __name__, template_folder='templates') github_blueprint = make_github_blueprint( client_id=app.config.get('GITHUB_ID'), client_secret=app.config.get('GITHUB_SECRET'), ) google_blueprint = make_google_blueprint( client_id=app.config.get('GOOGLE_ID'), client_secret=app.config.get('GOOGLE_SECRET'), scope=["profile", "email"]) twitter_blueprint = make_twitter_blueprint( api_key=app.config.get('TWITTER_API_KEY'), api_secret=app.config.get('TWITTER_API_SECRET')) facebook_blueprint = make_facebook_blueprint( client_id=app.config.get('FACEBOOK_APP_ID'), client_secret=app.config.get('FACEBOOK_APP_SECRET')) # setup SQLAlchemy backend github_blueprint.backend = SQLAlchemyBackend(models.OAuth, db.session, user=current_user) google_blueprint.backend = SQLAlchemyBackend(models.OAuth, db.session, user=current_user) twitter_blueprint.backend = SQLAlchemyBackend(models.OAuth, db.session,
import os import uuid from flask import flash, session, redirect, url_for from flask_dance.consumer import oauth_authorized, oauth_error from flask_dance.consumer.storage.sqla import SQLAlchemyStorage from flask_dance.contrib.twitter import make_twitter_blueprint from flask_login import current_user, login_user from sqlalchemy.orm.exc import NoResultFound from models import db, Users, OAuth blueprint = make_twitter_blueprint( storage=SQLAlchemyStorage(OAuth, db.session, user=current_user), api_key=os.environ.get('TWITTER_API_KEY'), api_secret=os.environ.get('TWITTER_API_SECRET'), redirect_to="check_login", ) # create/login local user on successful OAuth login @oauth_authorized.connect_via(blueprint) def twitter_logged_in(blueprint, token): if not token: flash("Failed to log in.", category="error") return False resp = blueprint.session.get( "account/verify_credentials.json?include_email=true") if not resp.ok: msg = "Failed to fetch user info."
app = Flask(__name__) app.config['DEBUG'] = os.environ['DEBUG'] app.config['SECRET_KEY'] = os.environ['SECRET_KEY'] app.config['DATABASE_URL'] = os.environ['DATABASE_URL'] app.config['SQLALCHEMY_DATABASE_URI'] = app.config['DATABASE_URL'] app.config['BROKER_URL']=os.environ['REDISGREEN_URL'] app.config['CELERY_RESULT_BACKEND']=os.environ['REDISGREEN_URL'] app.debug = True # os.environ variable are either in .env (locally), or set via heroku config:set TWITTER_KEY=XXXXXXX twitter_blueprint = make_twitter_blueprint( api_key=os.environ['TWITTER_KEY'], api_secret=os.environ['TWITTER_SECRET'], redirect_url=os.environ['REDIRECT_URL'], ) app.register_blueprint(twitter_blueprint, url_prefix="/login") import communalblocklist.models from communalblocklist.models import User, Topic, db import communalblocklist.views import communalblocklist.api import communalblocklist.tasks # Start login manager login_manager = LoginManager() login_manager.init_app(app) login_manager.login_view = "auth"
from flask import Flask, redirect, url_for from flask_dance.contrib.twitter import make_twitter_blueprint, twitter from flask_sqlalchemy import SQLAlchemy from flask_login import UserMixin, current_user, LoginManager, login_required, login_user, logout_user from flask_dance.consumer.storage.sqla import OAuthConsumerMixin, SQLAlchemyStorage from flask_dance.consumer import oauth_authorized from sqlalchemy.orm.exc import NoResultFound from datetime import timedelta app = Flask(__name__) app.config['SECRET_KEY'] = 'dev' app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///login.db' # app.config['REMEMBER_COOKIE_DURATION'] = timedelta(seconds=20) twitter_blueprint = make_twitter_blueprint( api_key="SHc4zGhsJmpZ2kXOQl59OIOEV", api_secret="vyJbLO79rTWnzibfLwSiljX90hekeoiSaOORLx4C1Anbg55iDJ") app.register_blueprint(twitter_blueprint, url_prefix='/twitter_login') db = SQLAlchemy(app) login_manager = LoginManager(app) class User(UserMixin, db.Model): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(250), unique=True) class OAuth(OAuthConsumerMixin, db.Model): user_id = db.Column(db.Integer, db.ForeignKey(User.id))
from flask_dance.consumer.backend import BaseBackend from config.keys import Keys from data.articles import Articles app = Flask(__name__) app.config["MYSQL_HOST"] = "localhost" app.config["MYSQL_USER"] = "******" app.config["MYSQL_PASSWORD"] = "******" app.config["MYSQL_DB"] = "flask" app.config["MYSQL_CURSORCLASS"] = "DictCursor" mysql = MySQL(app) blueprint = make_twitter_blueprint(api_key = Keys.getTwitterKeys()["apiKey"], api_secret = Keys.getTwitterKeys()["apiSecret"]) app.register_blueprint(blueprint, url_prefix="/twitter_login") # class FileBackend(BaseBackend): # def __init__(self, filepath): # super(FileBackend, self).__init__() # self.filepath = filepath # def get(self, blueprint): # if not os.path.exists(self.filepath): # return None # with open(self.filepath) as f: # return json.load(f) # def set(self, blueprint, token): # with open(self.filepath, "w") as f:
def _make_app(*args, **kwargs): app = Flask(__name__) app.secret_key = "whatever" blueprint = make_twitter_blueprint(*args, **kwargs) app.register_blueprint(blueprint) return app
app = Flask(__name__, static_url_path="", static_folder="static") app.wsgi_app = ProxyFix(app.wsgi_app) app.config['MAIL_SERVER'] = 'smtp.gmail.com' app.config['MAIL_PORT'] = 465 app.config['MAIL_USERNAME'] = '******' app.config['MAIL_PASSWORD'] = '******' app.config['MAIL_USE_TLS'] = False app.config['MAIL_USE_SSL'] = True mail = Mail(app) # Social Networking integrations app.config['SECRET_KEY'] = 'thisismysecret' twitter_blueprint = make_twitter_blueprint(api_key='', api_secret='') # twitter password : metooapp app.register_blueprint(twitter_blueprint, url_prefix='/twitter_login') ''' @app.route("/twitter_login") def twitter_login(): if not twitter.authorized: return redirect(url_for('twitter.login')) account_info = twitter.get('account/settings.json') if account_info.ok: return '<h1>Your Twitter name is @{}</h1>'.format(account_info_json['screen_name']) return '<h1>Request failed!' ''' app.secret_key = 'thisismysecret'
from flask import Flask from flask_bootstrap import Bootstrap from flask_dance.contrib.twitter import make_twitter_blueprint from flask_sqlalchemy import SQLAlchemy from config import Config import logging logging.basicConfig() app = Flask(__name__) app.config.from_object(Config) twitter_blueprint = make_twitter_blueprint( api_key=app.config["TWITTER_API_KEY"], api_secret=app.config["TWITTER_API_SECRET"]) app.register_blueprint(twitter_blueprint, url_prefix='/login') Bootstrap(app) db = SQLAlchemy(app) from views import *
app = Flask(__name__) app.secret_key = "supersekrit" f = open('tw_request/.env', 'r') keyDict = dict() for s in f.readlines(): k, v = s.split('=', 1) k = k.strip() v = v.strip() keyDict[k] = v api_key = keyDict['TWITTER_API_KEY'] api_secret = keyDict['TWITTER_API_SECRET'] blueprint = make_twitter_blueprint(api_key=api_key, api_secret=api_secret) app.register_blueprint(blueprint, url_prefix="/login") client = pymongo.MongoClient(keyDict['MONGODB_URL'], connect=False, ssl_cert_reqs=ssl.CERT_NONE) db = client.main cache = client.cache f.close() def authorization_required(fun): def decorated(*args): if not twitter.authorized: abort(401)
from flask import Flask, jsonify, request, redirect, session, url_for # from flask_ngrok import run_with_ngrok from flask_dance.consumer import OAuth2ConsumerBlueprint from flask_dance.contrib.twitter import make_twitter_blueprint, twitter import bcrypt from models import User from requests_oauthlib import OAuth2Session from requests_oauthlib.compliance_fixes import facebook_compliance_fix import csv app = Flask(__name__) # run_with_ngrok(app) twitter_blueprint = make_twitter_blueprint( api_key='uQyFwItPPYK9EpXsurufWm52O', api_secret='lpe1StRf9QXhn8hsu2EQfh9KFwAd8hGMmZi7qHzpxZYfwSqh7Y') app.register_blueprint(twitter_blueprint, url_prefix='/twitter_login') app.secret_key = "<ISHOULDBESOMETHING>" tasks = [{ 'id': 1, 'title': u'Buy groceries', 'description': u'Milk, Cheese, Pizza, Fruit, Tylenol', 'done': False }, { 'id': 2, 'title': u'Learn Python', 'description': u'Need to find a good Python tutorial on the web', 'done': False }]
google_blueprint = make_google_blueprint( client_id=Config.OAUTH_CREDENTIALS['google']['client_id'], client_secret=Config.OAUTH_CREDENTIALS['google']['client_secret'], scope=[ 'openid', 'https://www.googleapis.com/auth/userinfo.profile', 'https://www.googleapis.com/auth/userinfo.email', ], redirect_to='google.login', ) #Facebook Login facebook_blueprint = make_facebook_blueprint( client_id=Config.OAUTH_CREDENTIALS['facebook']['id'], client_secret=Config.OAUTH_CREDENTIALS['facebook']['secret'], scope='email', redirect_to='facebook.login') #GIthub Login github_blueprint = make_github_blueprint( client_id=Config.OAUTH_CREDENTIALS['github']['client_id'], client_secret=Config.OAUTH_CREDENTIALS['github']['client_secret'], scope=['user, repo'], redirect_to='github.login') #Twiter Login twitter_blueprint = make_twitter_blueprint( api_key=Config.OAUTH_CREDENTIALS['twitter']['id'], api_secret=Config.OAUTH_CREDENTIALS['twitter']['secret'], redirect_to='login_twitter', )
from flask import Flask from app.config import Config from flask_sqlalchemy import SQLAlchemy from flask_migrate import Migrate from flask_login import LoginManager from flask_jwt_extended import JWTManager from flask_dance.contrib.twitter import make_twitter_blueprint app = Flask(__name__) jwt = JWTManager(app) app.config.from_object(Config) app.config['JWT_SECRET_KEY'] = 'super-secret' db = SQLAlchemy(app) migrate = Migrate(app, db) login = LoginManager(app) login.login_view = 'login' app.debug = True from app.api import bp as api_bp twitter_blueprint = make_twitter_blueprint(api_key='YKBGyqhWgdYnSG9jMgwGnHaKo', api_secret='CGgGn4PMRxlDs1wJ7vdIhvvrEJXdkOMs3N3edupYddCyT5NHgj') app.register_blueprint(api_bp, url_prefix='/api') app.register_blueprint(twitter_blueprint, url_prefix='/twitter_login') if __name__=="__main__": app.run()
from flask import flash from flask_login import current_user, login_user from flask_dance.contrib.twitter import make_twitter_blueprint from flask_dance.consumer import oauth_authorized, oauth_error from flask_dance.consumer.storage.sqla import SQLAlchemyStorage from sqlalchemy.orm.exc import NoResultFound from .models import db, User, OAuth blueprint = make_twitter_blueprint(storage=SQLAlchemyStorage( OAuth, db.session, user=current_user), redirect_to='tweet_page') # create/login local user on successful OAuth login @oauth_authorized.connect_via(blueprint) def twitter_logged_in(blueprint, token): if not token: flash("Failed to log in.", category="error") return False resp = blueprint.session.get("account/verify_credentials.json") if not resp.ok: msg = "Failed to fetch user info." flash(msg, category="error") return False info = resp.json() user_id = info["id_str"] # Find this OAuth token in the database, or create it query = OAuth.query.filter_by(
from instance.settings import AWS_CLIENT_ACCESS_KEY, AWS_CLIENT_SECRET_KEY from instance.settings import FACEBOOK_OAUTH_CLIENT_ID, \ FACEBOOK_OAUTH_CLIENT_SECRET from instance.settings import GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRETS from instance.settings import TWITTER_API_KEY, TWITTER_API_SECRET from winejournal.data_models.oauth import Oauth from winejournal.data_models.tastingnotes import TastingNote from winejournal.data_models.users import User from winejournal.data_models.wines import Wine from winejournal.extensions import db from winejournal.extensions import login_manager staticPages = Blueprint('static_pages', __name__, template_folder='templates') twitter_blueprint = make_twitter_blueprint( api_key=TWITTER_API_KEY, api_secret=TWITTER_API_SECRET) twitter_blueprint.backend = SQLAlchemyBackend( Oauth, db.session, user=current_user, user_required=False) google_blueprint = make_google_blueprint( client_id=GOOGLE_CLIENT_ID, client_secret=GOOGLE_CLIENT_SECRETS, scope=['profile', 'email']) google_blueprint.backend = SQLAlchemyBackend( Oauth, db.session, user=current_user,
# Local Modules from string_analyzer import StringAnalyser from twitter_client import TwitterClient from image_analysis import ImageAnalyser from matcher import Matcher, LOCAL_DOG_IMAGES # Global Variables string_analyzer = StringAnalyser() twitter_client = TwitterClient() image_analyzer = ImageAnalyser() matcher = Matcher() # Create our flask object app = Flask(__name__, static_url_path="", static_folder="templates/static") app.secret_key = "supersekrit" blueprint = make_twitter_blueprint( api_key=os.environ['CONSUMER_KEY'], api_secret=os.environ['CONSUMER_SECRET'], ) app.register_blueprint(blueprint, url_prefix="/login") # Create our database data DB_NAME = 'woof-are-you' DB_HOST = 'ds063160.mlab.com' DB_PORT = 63160 DB_USER = os.environ['MONGO_USER'] DB_PASS = os.environ['MONGO_PASS'] connection = MongoClient(DB_HOST, DB_PORT, retryWrites=False) db = connection[DB_NAME] db.authenticate(DB_USER, DB_PASS) db_client = db.user_data # client = MongoClient(f"mongodb://{os.environ['MONGO_USER']}:{os.environ['MONGO_PASS']}>@ds063160.mlab.com:63160/woof-are-you") # database = client.local
app = Flask(__name__) app.debug = True app.secret_key = os.environ.get("FLASK_SECRET_KEY", "supersekrit") app.config["SECRET_KEY"] = "maxseCretPliz18882" os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1' #Database db = Memgraph() #SCSS Scss(app, static_dir='static', asset_dir='assets') # Twitter connector twitter_bp = make_twitter_blueprint( api_key="AckLZqFrceE6E2EctXUF1Bmly", api_secret="CJlkvc0xfQYi731uICahGIJ9mrSw7zYYu7S3EmB7CCftkDASSr", ) app.register_blueprint(twitter_bp, url_prefix="/twitter_login") # Twitter connection @app.route("/twitter") def twitter_login(): if not facebook.authorized and not twitter.authorized: return redirect(url_for("twitter.login")) return redirect(url_for("profile")) # FB connector # app.config["FACEBOOK_OAUTH_CLIENT_ID"] = "3468111173224517" # app.config["FACEBOOK_OAUTH_CLIENT_SECRET"] = "7ea8279bf9d5de409cdf843e58ba0409"
from flask_dance.contrib.twitter import twitter as twitter_dance from flask import session, redirect, url_for, Blueprint import twitter from models import facade from views.google_views import login_required TWITTER_OAUTH_KEY = os.getenv("TWITTER_OAUTH_KEY") TWITTER_OAUTH_SECRET = os.getenv("TWITTER_OAUTH_SECRET") TWITTER_ACCESS_TOKEN = os.getenv("TWITTER_ACCESS_TOKEN") TWITTER_ACCESS_TOKEN_SECRET = os.getenv("TWITTER_ACCESS_TOKEN_SECRET") twitter_view = Blueprint('twitter_login', __name__) twitter_bp = make_twitter_blueprint(api_key=TWITTER_OAUTH_KEY, api_secret=TWITTER_OAUTH_SECRET, redirect_to='twitter_login.log_in_twitter') api = twitter.Twitter( auth=twitter.OAuth(consumer_key=TWITTER_OAUTH_KEY, consumer_secret=TWITTER_OAUTH_SECRET, token=TWITTER_ACCESS_TOKEN, token_secret=TWITTER_ACCESS_TOKEN_SECRET)) @twitter_view.route("/login") @login_required def log_in_twitter(user): if not twitter_dance.authorized: return redirect(url_for("twitter.login")) tag = "@" + twitter_dance.get(
from flask_dance.consumer.backend.sqla import SQLAlchemyBackend from flask_dance.contrib.facebook import make_facebook_blueprint from flask_dance.contrib.github import make_github_blueprint from flask_dance.contrib.twitter import make_twitter_blueprint from flask_login import current_user from project.utils.login import general_logged_in, general_error from project.models import OAuth, db facebook_blueprint = make_facebook_blueprint( backend=SQLAlchemyBackend(OAuth, db.session, user=current_user, user_required=False) ) twitter_blueprint = make_twitter_blueprint( backend=SQLAlchemyBackend(OAuth, db.session, user=current_user, user_required=False) ) github_blueprint = make_github_blueprint( backend=SQLAlchemyBackend(OAuth, db.session, user=current_user, user_required=False) ) @oauth_authorized.connect_via(twitter_blueprint) def twitter_logged_in(blueprint, token): return general_logged_in(blueprint, token, 'account/settings.json') @oauth_error.connect_via(twitter_blueprint) def twitter_error(blueprint, error, error_description=None, error_uri=None): return general_error(blueprint, error, error_description, error_uri)
from itsdangerous import URLSafeTimedSerializer, SignatureExpired from flask_marshmallow import Marshmallow from marshmallow import Schema, fields, pprint from flask_dance.contrib.twitter import make_twitter_blueprint, twitter from flask_dance.consumer.backend.sqla import OAuthConsumerMixin, SQLAlchemyBackend from flask_dance.consumer import oauth_authorized from sqlalchemy.orm.exc import NoResultFound from flask_login import LoginManager, login_user, UserMixin, current_user, logout_user, login_required app = Flask(__name__) CORS(app) # twitter login twitter_blueprint = make_twitter_blueprint( api_key='Wxheh706myGRPdIzg1UG8NCmD', api_secret='z2gPTdT8v1pCTNEX7xxtf0bbqLwLJgfiqgdgDa03GTf7M5m13T') app.register_blueprint(twitter_blueprint, url_prefix='/twitter_login') login_manager = LoginManager() login_manager.init_app(app) login_manager.login_view = "login" login_manager.login_message_category = "info" login_manager.refresh_view = "index" app.config.from_pyfile("config.cfg") mail = Mail(app) app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = True # app.config['SQLALCHEMY_ECHO'] = True app.config["SECRET_KEY"] = "thisissecretkey"