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