def github_login():
github = GitHub(app)
if not current_user.is_authenticated:
return github.authorize(scope="user")
else:
flash('You are already logged in.', 'success')
return redirect(url_for('public.home'))
def __init__(self, name=__name__):
# Host from parameters
Database.connect(host=args.mongo_host)
# Make sure default config is on
default_config = {
'voting_round': 1,
'voting_enabled': False,
'proposing_enabled': True
}
for key, value in default_config.items():
try:
get_config(key)
except:
Database.theme_slaughter.config.insert_one({
'_id': key,
'value': value
})
# App
app = Flask(name)
# Github config
app.config['SECRET_KEY'] = os.environ['SECRET_KEY']
app.config['GITHUB_CLIENT_ID'] = os.environ['GITHUB_CLIENT_ID']
app.config['GITHUB_CLIENT_SECRET'] = os.environ['GITHUB_CLIENT_SECRET']
self.github = GitHub(app)
# Server side sessions
app.config['SESSION_TYPE'] = 'mongodb'
app.config['SESSION_MONGODB'] = Database.session
Session(app)
# Create rules
app.add_url_rule('/', view_func=Index.as_view('index'))
app.add_url_rule('/propose', view_func=Propose.as_view('propose'))
app.add_url_rule('/vote', view_func=Vote.as_view('vote'))
app.add_url_rule('/login/<next_uri>', view_func=Login.as_view('login'))
app.add_url_rule('/do-login',
view_func=Authorize(self.github).as_view('do-login'))
# Github login related rules
app.add_url_rule('/github-callback',
view_func=self.github.authorized_handler(
AuthenticationHandler.as_view('github-callback')))
AuthenticationToken(self.github)
AuthenticationBefore(app, self.github)
self.app = app
def make_app(config_name):
app = Flask(__name__,instance_relative_config = True)
app.config['GITHUB_CLIENT_ID'] = 'XXX'
app.config['GITHUB_CLIENT_SECRET'] = 'YYY'
#For GitHub Enterprise
app.config['GITHUB_BASE_URL'] = 'https://HOSTNAME/api/v3/'
app.config['GITHUB_AUTH_URL'] = 'https://HOSTNAME/login/oauth/'
#creating app configs
app.config.from_object(config_options[config_name])
#flask extnsions
bootstrap.init_app(app)
db.init_app(app)
mail.init_app(app)
login_manager.init_app(app)
github.init_app(app)
###
github = GitHub(app)
# Registering the blueprints
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')
# setting config
###from .request import configure_request
###configure_request(app)
return app
def start(project_name, analyser_access_token, email_sender=None):
app = current_app._get_current_object()
analyse_github = GitHub(app)
@analyse_github.access_token_getter
def token_getter():
# print("another place %s" % analyser_access_token)
return analyser_access_token
try:
analyse_github.get('repos/%s' % project_name)
except:
return False
Thread(target=start_analyse,
args=[app, project_name, analyse_github, email_sender]).start()
return True
def check_repo(repo, access_token):
""" Check repo existence.
Args:
repo(full name), access_token
Returns:
None for not found,
json result for found.
"""
app = current_app._get_current_object()
github_api_caller = GitHub(app)
@github_api_caller.access_token_getter
def token_getter():
return access_token
try:
result = github_api_caller.get('repos/%s' % repo)
except:
return None
return result
def start(project_name, analyser_access_token):
app = current_app._get_current_object()
analyse_github = GitHub(app)
@analyse_github.access_token_getter
def token_getter():
# print("another place %s" % analyser_access_token)
return analyser_access_token
Thread(target=start_analyse, args=[app, project_name,
analyse_github]).start()
def authorized():
github = GitHub(app)
if 'code' in request.args:
access_token = github._handle_response()
else:
access_token = github._handle_invalid_response()
if not access_token:
flash('Error getting access token.', 'warning')
return redirect(url_for('public.home'))
r = requests.get('https://api.github.com/user',
params={"access_token": access_token})
user_details = json.loads(r.content)
if not user_details:
flash('Error getting user details.', 'warning')
return redirect(url_for('public.home'))
# if necessary, add user
github_username = user_details["login"]
email = user_details["email"]
if not email:
email = github_username
user = User.query.filter_by(github_username=github_username).first()
if user:
login_user(user)
flash('You have logged-in using GitHub.', 'success')
if not user:
user = User.create(username=github_username,
email=email,
github_username=github_username)
login_user(user)
flash('You have logged-in using GitHub for the first time.', 'success')
return redirect(url_for('public.home'))
def start_analyse(repo, access_token):
""" Start analyse on repo using github_api_caller(contains personal access token)
Args:
app context, repo, github_api_caller
Returns:
None
"""
app = current_app._get_current_object()
github_api_caller = GitHub(app)
@github_api_caller.access_token_getter
def token_getter():
return access_token
print("-----start analysing for %s-----" % repo)
repo_info = github_api_caller.get('repos/%s' % repo)
print('finish fetch repo info for %s' % repo)
# Save forks' list into local
forks_list_path = current_app.config[
'LOCAL_DATA_PATH'] + "/" + repo + '/forks_list.json'
if current_app.config['USE_LOCAL_FORKS_LIST'] and os.path.exists(
forks_list_path):
with open(forks_list_path) as read_file:
repo_forks_list = json.load(read_file)
else:
repo_forks_list = github_api_caller.request('GET',
'repos/%s/forks' % repo,
True)
localfile_tool.write_to_file(forks_list_path, repo_forks_list)
print('finish fetch fork list for %s' % repo)
project_updater.start_update(repo, repo_info, repo_forks_list)
send_mail_for_repo_finish(repo)
print("-----finish analysing for %s-----" % repo)
def test_authorization(self, auth_url, post):
def assert_params(*args, **kwargs):
data = kwargs.pop('data')
assert data['client_id'] == '123'
assert data['client_secret'] == 'SEKRET'
assert data['code'] == 'KODE'
response = Mock()
response.content = b'access_token=asdf&token_type=bearer'
return response
post.side_effect = assert_params
auth_url.__get__ = Mock(return_value='http://localhost/oauth/')
app = Flask(__name__)
app.config['GITHUB_CLIENT_ID'] = '123'
app.config['GITHUB_CLIENT_SECRET'] = 'SEKRET'
github = GitHub(app)
@app.route('/login')
def login():
return github.authorize(redirect_uri="http://localhost/callback")
@app.route('/callback')
@github.authorized_handler
def authorized(token):
access_token.append(token)
return ''
# Mimics GitHub authorization URL
# http://developer.github.com/v3/oauth/#web-application-flow
@app.route('/oauth/authorize')
def handle_auth():
logger.info("in /oauth/authorize")
called_auth.append(1)
assert request.args['client_id'] == '123'
logger.debug("client_id OK")
assert request.args['redirect_uri'] == 'http://localhost/callback'
logger.debug("redirect_uri OK")
return redirect(request.args['redirect_uri'] + '?code=KODE')
access_token = []
called_auth = []
client = app.test_client()
client.get('/login', follow_redirects=True)
assert called_auth
assert access_token == ['asdf'], access_token
from flask import Flask
from flask_github import GitHub
from util import localfile
app = Flask(__name__)
app.config['GITHUB_CLIENT_ID'] = os.environ.get('GITHUB_CLIENT_ID')
app.config['GITHUB_CLIENT_SECRET'] = os.environ.get('GITHUB_CLIENT_SECRET')
app.config['GITHUB_BASE_URL'] = 'https://api.github.com/'
app.config['GITHUB_AUTH_URL'] = 'https://github.com/login/oauth/'
LOCAL_DATA_PATH = '/DATA/luyao'
api = GitHub(app)
@api.access_token_getter
def token_getter():
access_token = '7246c27f8923b2baa4fedd19d7bd64b4d0aa1f0f'
# 7246c27f8923b2baa4fedd19d7bd64b4d0aa1f0f
# 9abfb768ed9daa5e59b782bc45f4d49d8b6ed371
return access_token
def text2list_precheck(func):
def proxy(text):
if text is None:
return []
import traceback
from urllib.request import Request, urlopen
from flask import Flask, redirect, render_template, request, session, url_for
from flask_github import GitHub
from openutils.handlers import HANDLERS
APP = Flask(__name__)
APP.config["SESSION_TYPE"] = "filesystem"
APP.config["GITHUB_CLIENT_ID"] = os.getenv("GITHUB_CLIENT_ID")
APP.config["GITHUB_CLIENT_SECRET"] = os.getenv("GITHUB_CLIENT_SECRET")
APP.secret_key = os.getenv("FLASK_SECRET_KEY", secrets.token_urlsafe(64))
GITHUB = GitHub(APP)
@APP.route("/")
def index():
if (authorization := session.get("authorization")) is not None:
if authorization:
error = "Successfully logged in!"
else:
error = "Couldn't logged in!"
return render_template("index.html", error=None)
@APP.route("/query")
def query():
GITHUB_AUTH_ROUTE = '/github-auth'
GITHUB_CALLBACK_ROUTE = '/github-callback'
FINALIZE_GITHUB_AUTH_ROUTE = '/api/finalize-github-auth'
GITHUB_CLIENT_ID = Config.GITHUB_CLIENT_ID
GITHUB_CLIENT_SECRET = Config.GITHUB_CLIENT_SECRET
#Current scopes include all read access available in the API
GITHUB_SCOPES = "user, repo, read:org, read:public_key, gist, notifications, read:discussion, read:packages', read:gpg_key, workflow"
#construct GitHub object
#Using default constructor and then replicating GitHub.init_app(self, app)
#See https://github.com/cenkalti/github-flask/blob/master/flask_github.py
gitCreds = GitHubCredentials()
gitCreds.client_id = Config.GITHUB_CLIENT_ID
gitCreds.client_secret = Config.GITHUB_CLIENT_SECRET
gitCreds.base_url = 'https://api.github.com/'
gitCreds.auth_url = 'https://github.com/login/oauth/'
gitCreds.session = requests.session()
#Call to attempt to authorize a user with the GitHub API
@application.route(GITHUB_AUTH_ROUTE)
def github_auth_route():
return gitCreds.authorize(scope=GITHUB_SCOPES)
#Invoked after github authorization attempt
@application.route(GITHUB_CALLBACK_ROUTE)
def build_github_login_service(app):
"""Adds the login service
Before adding this service, both ``GITHUB_CLIENT_ID`` and ``GITHUB_CLIENT_SECRET`` need to be set in the app's
configuration
:param flask.Flask app: A Flask app
"""
app.config.update({
'GITHUB_CLIENT_ID':
os.environ[PYBEL_GITHUB_CLIENT_ID],
'GITHUB_CLIENT_SECRET':
os.environ[PYBEL_GITHUB_CLIENT_SECRET]
})
# flask-login
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'login'
# setup github-flask
github = GitHub(app)
@github.access_token_getter
def token_getter():
if current_user is not None:
return current_user.id
@app.route('/login', methods=['GET', 'POST'])
def login():
if session.get('user_id', None) is None:
return github.authorize()
else:
flask.flash('Already logged in')
return redirect(url_for('index'))
@app.route('/github-callback')
@github.authorized_handler
def authorized(access_token):
next_url = request.args.get('next') or url_for('view_networks')
if access_token is None:
return redirect(next_url)
user = User(access_token)
if app.config.get('PYBEL_WEB_STRICT_LOGIN') and not user.name:
flash(
'Please add your name to your GitHub account to use PyBEL Web')
return redirect(url_for('index'))
login_user(user)
login_log.info('Login from %s by %s (%s)', request.remote_addr,
user.name, user.username)
return redirect(next_url)
@app.route('/logout')
@login_required
def logout():
logout_user()
flash('Logged out')
return redirect(url_for('view_networks'))
@app.errorhandler(401)
def page_not_found(e):
return Response('<p>Login failed</p>')
# callback to reload the user object
@login_manager.user_loader
def load_user(id):
return User(id)
@app.route('/user')
@login_required
def show_user():
return jsonify(github.get('user'))
from sqlalchemy.orm import scoped_session, sessionmaker
from sqlalchemy.ext.declarative import declarative_base
# flask app
app = Flask(__name__, instance_relative_config=True)
app.config.update(
dict(
DATABASE=os.path.join(app.root_path, 'app.db'),
DEBUG=False,
))
app.config.from_envvar('FLASKR_SETTINGS', silent=True)
app.config.from_pyfile('config.py')
# flask-github
flask_github = GitHub(app)
# sqlalchemy
engine = create_engine("sqlite:///%s" % app.config['DATABASE'])
db_session = scoped_session(
sessionmaker(autocommit=False, autoflush=False, bind=engine))
Base = declarative_base()
Base.query = db_session.query_property()
class User(Base):
__tablename__ = 'users'
id = Column(Integer, primary_key=True)
username = Column(String(200))
access_token = Column(String(200))
# load .env
load_dotenv()
# hack
os.environ['SERVER_SOFTWARE'] = 'Google App Engine/'
app = Flask(__name__)
# load in
try:
app.config['GITHUB_CLIENT_ID'] = os.environ['GITHUB_CLIENT_ID']
app.config['GITHUB_CLIENT_SECRET'] = os.environ['GITHUB_CLIENT_SECRET']
except Exception as e:
raise e
github = GitHub(app)
GRAPH = None
def register_graph():
global GRAPH
if not GRAPH:
try:
GRAPH = KnowledgeGraph()
except:
raise Exception("Failed to load existing graph from file")
@app.route('/')
def index():
return redirect(url_for('get_graph'))
from flask import render_template
from flask import request
from flask import session
from flask import redirect
from flask import url_for
from flask import abort
from flask_github import GitHub
from flask_github import GitHubError
from User.models import User
from config import con
from tools import if_login
from tools import login_dec
from tools import unlogin_dec
user_r = Blueprint('user', __name__, template_folder='templates/User')
github = GitHub(con.app)
error = None
@user_r.route('/login/', methods=['GET'])
@unlogin_dec
def login():
if request.method == 'GET':
global error
if error is None:
return render_template('User/login.html')
else:
e = error
error = None
return render_template('User/login.html', error=e)
def create_app(test_config=None):
# create and configure the app
app = Flask(__name__, instance_relative_config=True)
app.config.from_mapping(
SECRET_KEY=os.environ.get('SECRET_KEY', 'dev'),
MONGO_URI=os.environ.get('MONGO_URI', 'localhost:27017'),
GITHUB_CLIENT_ID=os.environ.get('GITHUB_CLIENT_ID'),
GITHUB_CLIENT_SECRET=os.environ.get("GITHUB_SECRET_KEY"))
app.json_encoder = MongoJSONEncoder
app.url_map.converters['objectid'] = ObjectIdConverter
if test_config is None:
# load the instance config, if it exists, when not testing
app.config.from_pyfile('config.py', silent=True)
else:
# load the test config if passed in
app.config.from_mapping(test_config)
# ensure the instance folder exists
try:
os.makedirs(app.instance_path)
except OSError:
pass
# Making a Mongo Connection to our database
mongo = PyMongo(app)
# a simple page that says hello
@app.route('/hello')
def hello():
return jsonify({"title": 'Hello, World!'})
github = GitHub(app)
@app.before_request
def before_request():
g.user = None
if 'user_id' in session:
g.user = mongo.db.user.find_one({'user_id': session['user_id']})
@app.route('/')
def index():
uid = session.get('user_id', None)
users = None
if uid is not None:
users = mongo.db.user.find_one({'user_id': session.get('user_id')})
print(users)
projects = mongo.db.project.find()
return render_template('home.html', user=users, projects=projects)
@github.access_token_getter
def token_getter():
user = g.user
if user is not None:
return user.get('github_access_token', None)
@app.route('/github-callback')
@github.authorized_handler
def authorized(access_token):
next_url = request.args.get('next') or url_for('index')
if access_token is None:
return redirect(next_url)
user = mongo.db.user.find_one({'github_access_token': access_token})
if user is None:
user = {'github_access_token': access_token}
user['github_access_token'] = access_token
g.user = user
if user.get('user_id', None) is None:
github_user = github.get('/user')
user['user_id'] = github_user['login']
user['email'] = github_user['email']
user['profile'] = github_user['html_url']
user['name'] = github_user['name']
mongo.db.user.replace_one({"user_id": user['user_id']},
user,
upsert=True)
g.user = user
session['user_id'] = user['user_id']
return redirect(next_url)
@app.route('/login')
def login():
if session.get('user_id', None) is None:
return github.authorize()
else:
return redirect(url_for('index'))
@app.route('/logout')
def logout():
session.pop('user_id', None)
return redirect(url_for('index'))
@app.route('/projects/all')
def projects():
projects = [proj for proj in mongo.db.projects.find()]
return jsonify(projects)
@app.route('/projects/<slug>')
def get_project(slug):
project = mongo.db.projects.find_one({'slug': slug})
return jsonify(project)
@app.route('/projects/create', methods=['GET', 'POST'])
def create_project():
if request.method == 'GET':
return render_template('projectForm.html')
if session.get('user_id', None) is None:
return abort(401, 'Log in to post a new project.')
body = request.get_json()
if body.get('project_name', None) is None:
return abort(400, 'project_name needed in body. None found.')
slug = slugify(body['project_name'])
if mongo.db.projects.find_one({'slug': slug}) is not None:
flash(f'Project named {project_name} already exists.')
return redirect(url_for(get_project, slug=slug))
project = {
key: body[key]
for key in body.keys()
if (key != 'comments') and (key in project_schema.keys())
}
project['slug'] = slug
for key in project_schema.keys():
if key not in project.keys():
if key in ['comments', 'members']:
project[key] = []
else:
project[key] = ""
elif key in ['comments', 'members']:
if not isinstance(project[key], list):
return abort(
400,
f'Invalid data type passed for {key}. Expected list.')
elif not isinstance(project[key], str):
return abort(
400,
f'Invalid data type passed for {key}. Expected string.')
mongo.db.projects.replace_one(project, project, upsert=True)
# TODO return and redirect to posted project details
flash('Project created successfully')
return redirect(url_for('projects'))
@app.route('/projects/<slug>/update', methods=['POST'])
def update_project(slug):
if session.get('user_id', None) is None:
return abort(401, 'Log in to update a project.')
project = mongo.db.projects.find_one({'slug', slug})
if project is None:
return abort(400, 'Project not found.')
elif project['owner_id'] != session['user_id']:
return abort(401, 'You are not the project owner.')
body = request.get_json()
for key in body:
if (key in project.keys()) and (key not in [
'project_name',
]):
project[key] = body[key]
mongo.db.projects.replace_one(
{'project_name': project['project_name']}, project, upsert=True)
return jsonify(project), 200
@app.route('/projects/<slug>/delete')
def delete_project(slug):
if session.get('user_id', None) is None:
return abort(401, 'Log in to delete a project.')
project = mongo.db.projects.find_one({'slug': slug})
if project is None:
return abort(400, 'Project not found.')
elif project['owner_id'] != session['user_id']:
return abort(401, 'You are not the project owner.')
else:
mongo.db.projects.delete_one({'_id': project['_id']})
return 'Delete successful', 200
return app
from fastcore.xtras import obj2dict
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import scoped_session, sessionmaker
from sqlalchemy.ext.declarative import declarative_base
DATABASE_URI = 'sqlite:///backend\\github-flask.db'
SECRET_KEY = 'development key'
DEBUG = True
GITHUB_CLIENT_ID = '8b069af36a352b27c01c'
GITHUB_CLIENT_SECRET = 'f3d775d909b27caa635fae3eb9c7700287a3919e'
app = Flask(__name__)
app.config.from_object(__name__)
github = GitHub(app) #using for OAuth
engine = create_engine(app.config['DATABASE_URI'])
db_session = scoped_session(
sessionmaker(autocommit=False, autoflush=False, bind=engine))
Base = declarative_base()
Base.query = db_session.query_property()
def init_db():
Base.metadata.create_all(bind=engine)
class User(Base):
__tablename__ = 'users'
Compress(app)
api = flask_restful.Api(app)
app.config['MONGO_URI'] = os.getenv('MONGODB_URI', 'mongodb://localhost:27017/worlddriven')
CORS(
app,
origins=['http://localhost:5000', DOMAIN],
supports_credentials=True)
mongo = PyMongo(app)
apiendpoint.mongo = mongo
app.config['GITHUB_CLIENT_ID'] = os.getenv('GITHUB_CLIENT_ID')
app.config['GITHUB_CLIENT_SECRET'] = os.getenv('GITHUB_CLIENT_SECRET')
github_oauth = GitHub(app)
@app.before_request
def before_request():
g.user = None
if 'user_id' in session:
user = mongo.db.users.find_one({'_id': ObjectId(session['user_id'])})
g.user = user
@github_oauth.access_token_getter
def token_getter():
user = g.user
if user is not None:
user = user['github_access_token']
return user
from flask_github import GitHub from flask_migrate import Migrate from flask_sqlalchemy import SQLAlchemy db = SQLAlchemy() migrate = Migrate() github_oauth = GitHub()
from flask import Flask
from flask import request, url_for
from flask_bootstrap import Bootstrap
from flask_mongoengine import MongoEngine
from flask_login import LoginManager
from flask_github import GitHub
from flask_mail import Mail
from config import config
bootstrap = Bootstrap()
db = MongoEngine()
mail = Mail()
github = GitHub()
login_manager = LoginManager()
login_manager.session_protection = 'strong'
login_manager.login_view = 'auth.login'
def create_app(config_name):
""" factory function for create app
:param config_name
:return: app object
"""
app = Flask(__name__, static_folder='static')
def url_for_other_page(page):
args = request.view_args.copy()
#args = request.view_args.items()
#args.append(request.args.to_dict().items())
#args = dict(args)
from .utils.customCacheControl.heuristic import ZeroSecondsHeuristic
try:
__version__ = pkg_resources.require('gibolt')[0].version
except pkg_resources.DistributionNotFound:
__version__ = 'GIBOLT not installed in path'
app = Flask(__name__)
app.config.from_envvar('FLASK_CONFIG')
engine = create_engine(
app.config['SQLALCHEMY_DATABASE_URI'],
connect_args={'check_same_thread': False},
)
github = GitHub(app)
file_cache = FileCache('/tmp/gibolt-cache')
adapter = CacheControlAdapter(
cache=file_cache, controller_class=GitHubController
)
custom_adapter = CacheControlAdapter(
heuristic=ZeroSecondsHeuristic(),
cache=file_cache,
controller_class=GitHubController,
)
github.session = requests.Session()
github.session.mount('http://', adapter)
github.session.mount('https://', adapter)
# CacheControl always verifies the cache freshness before ETag
# To ensure data for repos are always up to date compared to Github,
# the cache freshness is defined to 0 by a custom caching strategy
