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 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
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"
