def __init__(self, app, install=True, prefix=None, name='GoogleAuth'): self.app = app self.app.config.setdefault('GOOGLE_DOMAIN', None) self.oid = OpenID(self.app) self.url_prefix = prefix self.name = name self.blueprint = self._get_blueprint(self.name) self.domain = self.app.config.get('GOOGLE_DOMAIN') self._login = self.oid.loginhandler(self.__login) self._create_or_login = self.oid.after_login(self.__create_or_login) if install: self.install()
flask_framework = Flask(__name__) flask_framework.config.from_object('config') orm_db = SQLAlchemy(flask_framework) resp = Response login_manager = LoginManager() login_manager.init_app(flask_framework) login_manager.login_view = 'login' login_manager.login_message = lazy_gettext( 'Please log in to access this page.') # OpenID service openID_service = OpenID(flask_framework, os.path.join(basedir, 'tmp')) mail = Mail(flask_framework) babel = Babel(flask_framework) ''' Flask - Principal ''' from flask.ext.principal import Principal, Permission, RoleNeed # load the extension principals = Principal(flask_framework) # Create a permission with a single Need, in this case a RoleNeed. comptroller_permission = Permission(RoleNeed('COMPT')) administrator_permission = Permission(RoleNeed('ADMIN')) ''' Exexcution Profiles ''' if not flask_framework.debug and MAIL_SERVER != '': import logging
import flask from flask.ext.openid import OpenID from flask.ext.pymongo import PyMongo import wtforms as wtf import logging import uuid import os app = flask.Flask(__name__) app.config.from_pyfile('config.py') # Set up session secret key app.secret_key = app.config['SESSION_SECRET_KEY'] # Set up OpenID oid = OpenID(app, app.config['OPENID_STORE']) # Set up MongoDB mongo = PyMongo(app) # Set up logging if not app.debug: file_handler = logging.FileHandler(app.config['LOGFILE']) file_handler.setLevel(logging.DEBUG) app.logger.addHandler(file_handler) def generate_uuid(): while True: the_uuid = str(uuid.uuid4()) if not mongo.db.registrations.find_one({'_id': the_uuid}):
# -*- coding: utf8 -*- from functools import wraps from flask import Flask, Blueprint, Markup, session, g, flash, redirect, url_for from flask.ext.sqlalchemy import SQLAlchemy from flask.ext.openid import OpenID from flask.ext.misaka import markdown app = Flask(__name__) app.config.from_object('config') db = SQLAlchemy(app) oid = OpenID(app, '/var/tmp') app.jinja_env.filters['markdown'] = markdown app.jinja_env.filters['markup'] = Markup @app.before_request def lookup_current_user(): g.user = None if 'user_id' in session: user_id = session['user_id'] g.user = User.query.get(user_id) if not g.user: session.clear('user_id') def login_required(func): @wraps(func) def wrapper(*args, **kwargs): if not g.user: flash('You must login to visit this page!')
from flask import Flask from flask.ext.sqlalchemy import SQLAlchemy from flask.ext.openid import OpenID from flask_mail import Mail app = Flask(__name__) app.config.from_envvar('CONFIG') oid = OpenID(app, '/tmp') db = SQLAlchemy(app) mail = Mail(app) import views
from flask import Blueprint, render_template, abort, g, request, Response, jsonify from jinja2 import TemplateNotFound from flask.ext.openid import OpenID from functools import wraps import json oid = OpenID('openid') # class BackendBlueprint(Blueprint): def client_required(self, f): @wraps(f) def decorated_function(*args, **kwargs): print "Check if client" if not g.backend_client: print "No client!" response = Response(json.dumps({ "error": { "type": "DGDB_API_Exception", "message": "The client was invalid. Contact your code monkey." } }), mimetype="application/json", status=404) return response return f(*args, **kwargs) return decorated_function
import os from flask import Flask from flask.ext.sqlalchemy import SQLAlchemy from flask.ext.login import LoginManager from flask.ext.openid import OpenID from config import BASE_DIR, BASE_URL, URLS_PER_PAGE from .base_62 import saturate, dehydrate app = Flask(__name__) app.config.from_object('config') db = SQLAlchemy(app) login_manager = LoginManager() login_manager.init_app(app) login_manager.login_view = 'login' openid = OpenID(app, os.path.join(BASE_DIR, 'tmp')) from app import views, models
# coding:utf-8 from flask import g, flash, session, Flask, redirect, url_for, render_template, request from flask.ext.login import logout_user, login_user, LoginManager, current_user from flask.ext.openid import OpenID app = Flask(__name__) #app.config.from_object('config') lm = LoginManager() lm.init_app(app) oid = OpenID(app, './tmp') import User import os import latex from Forms import LoginForm @app.route('/') @app.route('/index') def hello(): args = {} args['location'] = 'home' return render_template('index.html', args=args) @app.route('/generate_md', methods=['GET', 'POST']) def generate_md(): if request.method=='GET': return "<center><h1>HELLO</h1></md>" else: script = '''<script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS_HTML"></script>''' return script + "<body>" + markdown.markdown(request.form['data']) + "</body>"
from flask.ext.openid import OpenID import anitya.lib import anitya.mail_logging __version__ = '0.10.1' # Create the application. APP = flask.Flask(__name__) APP.config.from_object('anitya.default_config') if 'ANITYA_WEB_CONFIG' in os.environ: # pragma: no cover APP.config.from_envvar('ANITYA_WEB_CONFIG') # Set up OpenID APP.oid = OpenID(APP) # Set up the logging logging_config = { 'version': 1, 'disable_existing_loggers': False, 'formatters': { 'simple': { 'format': '[%(name)s %(levelname)s] %(message)s', }, }, 'handlers': { 'console': { 'class': 'logging.StreamHandler', 'formatter': 'simple', 'stream': 'ext://sys.stdout',
import docker from flask import Flask, render_template, session, g, \ redirect, url_for, request from flask.ext.bootstrap import Bootstrap from werkzeug import secure_filename import psutil import tempfile from dirlist_app import dirlist from flask.ext.openid import OpenID import sqlite3dbm app = Flask(__name__) app.secret_key = "arglebargle" oid = OpenID(app, os.path.join(os.path.dirname(__file__), 'openid_store')) UPLOAD_FOLDER = tempfile.mkdtemp() MOUNTPOINT = '/blah' ALLOWED_EXTENSIONS = set(['py']) DATABASE = '/tmp/database.sqlite3' app.config['BOOTSTRAP_USE_MINIFIED'] = True app.config['BOOTSTRAP_USE_CDN'] = True app.config['BOOTSTRAP_FONTAWESOME'] = True app.config['SECRET_KEY'] = app.secret_key app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER CONTAINER_STORAGE = "/tmp/containers.json" SERVICES_HOST = '127.0.0.1' BASE_IMAGE = 'ytproject/yt-devel'
async_mode = 'eventlet' eventlet.monkey_patch() except ImportError: try: from gevent import monkey async_mode = 'gevent' except ImportError: async_mode = 'threading' app = Flask(__name__) app.config.from_object('settings') socketio = SocketIO(app, async_mode=async_mode) db = SQLAlchemy(app) lm = LoginManager() lm.init_app(app) lm.login_view = 'login' oid = OpenID(app, os.path.realpath('tmp')) from app import views, models # TODO(hop): need fix logging if not app.debug: import logging from logging.handlers import RotatingFileHandler file_handler = RotatingFileHandler('tmp/sm.log', 'a', 1 * 1024 * 1024, 10) file_handler.setFormatter(logging.Formatter( '%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]')) app.logger.setLevel(logging.INFO) file_handler.setLevel(logging.INFO) app.logger.addHandler(file_handler)
from flask import Flask from flask.ext.sqlalchemy import SQLAlchemy from flask.ext.openid import OpenID from flask.ext.login import LoginManager scrim_app = Flask(__name__) scrim_app.config.from_pyfile('../config.py') lm = LoginManager() db = SQLAlchemy(scrim_app) oid = OpenID(scrim_app) lm.init_app(scrim_app) from scrim import views, models from models import User, Team, Scrim @scrim_app.context_processor def utility_processor(): def convert_days(bit_string): days_of_week = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"] aval = [ day for day, bit in zip(days_of_week, bit_string) if bit == '1' ] return aval def get_time_zone_label(time_zone): from consts import TIME_ZONES_DICT for item in TIME_ZONES_DICT: if item['time_zone'] == time_zone:
import ConfigParser, os import boto.ec2 import boto.sdb from werkzeug.debug import tbtools import cluster_monitor import argparse import logging import prices from instance_types import cpus_per_instance import batch_submit import json import base64 oid = OpenID(None, "/tmp/clusterui-openid") terminal_manager = term.TerminalManager() from werkzeug.local import LocalProxy def _get_current_config(): return flask.current_app.config config = LocalProxy(_get_current_config) def convert_to_boolean(name, value): value = value.lower() if value == 'true': return True if value == 'false': return False
app.config["MEMCACHED_PORT"]) ], key_prefix=app.config["MEMCACHED_KEY_PREFIX"]) elif app.config["CACHE_TYPE"].lower() == "simple": from werkzeug.contrib.cache import SimpleCache flask_cache = SimpleCache() else: from werkzeug.contrib.cache import NullCache flask_cache = NullCache() if app.config["PROXY_SETUP"]: app.wsgi_app = ProxyFix(app.wsgi_app) if app.config["OPENID_ENABLED"]: from flask.ext.openid import OpenID oid = OpenID(app, safe_roots=[]) from login import login app.register_blueprint(login) from dumpdirs import dumpdirs app.register_blueprint(dumpdirs, url_prefix="/dumpdirs") from reports import reports app.register_blueprint(reports, url_prefix="/reports") from problems import problems app.register_blueprint(problems, url_prefix="/problems") from stats import stats app.register_blueprint(stats, url_prefix="/stats") from summary import summary app.register_blueprint(summary, url_prefix="/summary")
#encoding=utf-8 #! ./env/bin/python import os from flask import Flask from flask_sqlalchemy import SQLAlchemy # login from flask.ext.login import LoginManager from flask.ext.openid import OpenID from config import basedir app = Flask(__name__) app.config.from_object('config') lm = LoginManager() lm.init_app(app) lm.login_view = 'login' # basedir 在哪里? oid = OpenID(app, os.path.join(basedir, 'tmp')) db = SQLAlchemy(app) # app/views.py from app import views, models
from .decorators import login_required, guest_or_login_required, with_lock from .decorators import global_lock # Make flask use the old session foo from <=flask-0.9 from flask_oldsessions import OldSecureCookieSessionInterface from flask.ext.autoindex import AutoIndex from sage.env import SAGE_SRC, SAGE_DOC SRC = os.path.join(SAGE_SRC, 'sage') from flask.ext.openid import OpenID from flask.ext.babel import Babel, gettext, ngettext, lazy_gettext, get_locale from sagenb.misc.misc import SAGENB_ROOT, DATA, translations_path, N_, nN_, unicode_str from json import dumps from sagenb.notebook.cell import number_of_rows from sagenb.notebook.template import (css_escape, clean_name, prettify_time_ago, TEMPLATE_PATH) oid = OpenID() class SageNBFlask(Flask): static_path = '' def __init__(self, *args, **kwds): self.startup_token = kwds.pop('startup_token', None) Flask.__init__(self, *args, **kwds) self.session_interface = OldSecureCookieSessionInterface() self.config['SESSION_COOKIE_HTTPONLY'] = False self.root_path = SAGENB_ROOT self.add_static_path('/css', os.path.join(DATA, "sage", "css"))
# -*- coding: utf-8 -*- import app as core from flask import ( Blueprint, request, current_app, g, render_template, redirect, flash, session, abort, url_for) from provider import BitTrailsProvider from models import AccessToken, User from auth.signals import services_registered from flask.ext.openid import OpenID app = Blueprint('oauth_provider', __name__, template_folder='templates') PROVIDER = BitTrailsProvider(current_app) PROVIDER.init_blueprint(app) oid = OpenID(current_app) @app.route('/') def index(): return render_template('index.html') @app.route('/callback') def callback(): return str(request.__dict__) @app.route('/login', methods=['GET', 'POST']) @oid.loginhandler def login(): """Does the login via OpenID. Has to call into `oid.try_login` to start the OpenID machinery.
from flask.ext.login import LoginManager from flask.ext.openid import OpenID from config import basedir app = Flask(__name__) app.config.from_object("config") db = SQLAlchemy(app) lm = LoginManager() lm.init_app(app) # Flask-Login 需要知道哪个视图允许用户登录 lm.login_view = 'login' # Flask-OpenID 扩展需要一个存储文件的临时文件夹的路径 oid = OpenID(app, os.path.join(basedir, "tmp")) from app import views, models if not app.debug: import logging from logging.handlers import RotatingFileHandler file_handler = RotatingFileHandler("tmp/M-blog.log", "a", 1 * 1024 * 1024, 10) file_handler.setFormatter( logging.Formatter( '%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]' )) app.logger.setLevel()
from flask import Flask, render_template, request, g, session, flash, \ redirect, url_for, abort from flask.ext.openid import OpenID import ujson as json from openid.extensions import pape import JumpScale.baselib.hrd # setup flask app = Flask(__name__) app.config['SECRET_KEY'] = 'sdsdsd' # setup flask-openid oid = OpenID(app, safe_roots=[], extension_responses=[pape.Response]) userhrdtemplate = """ login= email= name= alias=, company=, skype=, mobile=, jabber=, openid=, """ grouphrdtemplate = """ members=,
from flask import Flask, session, g, render_template from flask.ext.openid import OpenID app = Flask(__name__) app.config.from_object('websiteconfig') from flask_website.openid_auth import DatabaseOpenIDStore oid = OpenID(app, store_factory=DatabaseOpenIDStore) @app.errorhandler(404) def not_found(error): return render_template('404.html'), 404 @app.before_request def load_current_user(): g.user = User.query.filter_by(openid=session['openid']).first() \ if 'openid' in session else None @app.teardown_request def remove_db_session(exception): db_session.remove() app.add_url_rule('/docs/', endpoint='docs.index', build_only=True) app.add_url_rule('/docs/<path:page>/', endpoint='docs.show', build_only=True) app.add_url_rule('/docs/flask-docs.pdf', endpoint='docs.pdf', build_only=True) app.add_url_rule('/docs/flask-docs.zip', endpoint='docs.zip', build_only=True)
import time from flask import (g, flash, redirect, render_template, request, Response, session, url_for) from flask.ext.openid import OpenID from cya_server import app, settings from cya_server.models import (client_version, container_requests, hosts, shared_storage, users) oid = OpenID(app, settings.OPENID_STORE, safe_roots=[]) @app.before_request def lookup_current_user(): g.user = None if 'openid' in session: openid = session['openid'] g.user = users.get_user_by_openid(openid) @app.route('/login', methods=['GET', 'POST']) @oid.loginhandler def login(): if g.user is not None: return redirect(oid.get_next_url()) if request.method == 'POST': openid = request.form.get('openid') if openid: return oid.try_login(openid, ask_for=['email', 'nickname']) return render_template('login.html',
import anitya.forms import anitya.lib import anitya.lib.plugins import anitya.mail_logging __version__ = '0.8.0' # Create the application. APP = flask.Flask(__name__) APP.config.from_object('anitya.default_config') if 'ANITYA_WEB_CONFIG' in os.environ: # pragma: no cover APP.config.from_envvar('ANITYA_WEB_CONFIG') # Set up OpenID OID = OpenID(APP) # Set up the logging if not APP.debug: APP.logger.addHandler( anitya.mail_logging.get_mail_handler( smtp_server=APP.config.get('SMTP_SERVER', '127.0.0.1'), mail_admin=APP.config.get('MAIL_ADMIN', '*****@*****.**'))) # Log to stderr as well STDERR_LOG = logging.StreamHandler(sys.stderr) STDERR_LOG.setLevel(logging.INFO) APP.logger.addHandler(STDERR_LOG) ANITYALOG = logging.getLogger('anitya') ANITYALOG.addHandler(STDERR_LOG)
from chalicepoints.models.user import User PROJECT_ROOT = os.path.dirname(os.path.realpath(__file__)) app = Flask(__name__, static_folder=os.path.join(PROJECT_ROOT, 'public'), static_url_path='/public') app.config.from_object('chalicepoints.config.DefaultConfig') app.config['SECRET_KEY'] = os.getenv('APP_SECRET_KEY', app.config['SECRET_KEY']) if app.config['SECRET_KEY'] is None: abort(500) # Flask-OpenID open_id = OpenID() open_id.init_app(app) # Flask-Login login_manager = LoginManager() login_manager.login_view = 'site.login' login_manager.init_app(app) # Redis redis_url = os.getenv('REDISTOGO_URL', app.config['REDIS_URL']) r = redis.from_url(redis_url) def register_blueprint(app): from chalicepoints.views.site import site app.register_blueprint(site)
import datanommer.models # Create the application. app = flask.Flask(__name__) log = app.logger app.url_map.converters['not_reserved'] = fmn.web.converters.NotReserved # set up FAS app.config.from_object('fmn.web.default_config') if 'FMN_WEB_CONFIG' in os.environ: # pragma: no cover app.config.from_envvar('FMN_WEB_CONFIG') # Set up OpenID in stateless mode oid = OpenID(app, safe_roots=[], store_factory=lambda: None, url_root_as_trust_root=True) # Inject a simple jinja2 test -- it is surprising jinja2 does not have this. app.jinja_env.tests['equalto'] = lambda x, y: x == y # Also, allow 'continue' and 'break' statements in jinja loops app.jinja_env.add_extension('jinja2.ext.loopcontrols') fedmsg_config = fedmsg.config.load_config() db_url = fedmsg_config.get('fmn.sqlalchemy.uri') if not db_url: raise ValueError("fmn.sqlalchemy.uri must be present") fedmsg.meta.make_processors(**fedmsg_config)
OPENID_ENDPOINT = 'http://*****:*****@APP.route('/') def home(): userdata = None if 'loggedin' in flask.session: userdata = flask.session['user'] return flask.render_template('index.html', userdata=userdata) @APP.route('/logout') def logout(): flask.session = {} return flask.redirect('/')
from flask.ext.restful import Api from flask.ext.celery import Celery from flask.ext.debugtoolbar import DebugToolbarExtension from flask.ext.cache import Cache from flask_assets import Environment, Bundle from flask.ext.admin import Admin from flask_mail import Mail from flask_youku import Youku from flask_gzip import GZip # Create the Flask-Bcrypt's instance bcrypt = Bcrypt() # Create the Flask-OpenID's instance openid = OpenID() # Create the Flask-Principal's instance principals = Principal() # Create the Flask-Restful's instance restful_api = Api() # Create the Flask-Celery-Helper's instance flask_celery = Celery() # Create the Flask-DebugToolbar's instance debug_toolbar = DebugToolbarExtension() # Create the Flask-Cache's instance cache = Cache()
meta_argument, ) app = flask.Flask(__name__) app.config.from_object('datagrepper.default_config') app.config.from_envvar('DATAGREPPER_CONFIG') # Set up session secret key app.secret_key = app.config['SECRET_KEY'] # Set up datagrepper database db = SQLAlchemy(app) from datagrepper.models import Job, STRSTATUS # Set up OpenID oid = OpenID(app) # Read in the datanommer DB URL from /etc/fedmsg.d/ (or a local fedmsg.d/) fedmsg_config = fedmsg.config.load_config() fedmsg.meta.make_processors(**fedmsg_config) # Initialize a datanommer session. dm.init(fedmsg_config['datanommer.sqlalchemy.url']) # Initialize the cache. cache = dogpile.cache.make_region().configure( app.config.get('DATAGREPPER_CACHE_BACKEND', 'dogpile.cache.memory'), **app.config.get('DATAGREPPER_CACHE_KWARGS', {})) import datagrepper.widgets
from flask.ext.babel import lazy_gettext from flask.ext.login import LoginManager, current_user from flask.ext.openid import OpenID from werkzeug.routing import RequestRedirect chat = Blueprint('chat', __name__) db = SQLAlchemy() # define Login manager lm = LoginManager() lm.login_view = 'login' lm.login_message = lazy_gettext('Please log in to access this page.') # add OpenID login oid = OpenID(fs_store_path=os.path.join(basedir, 'tmp')) class CustomAdminIndexView(MyAdminIndexView): @expose('/') def index(self): if current_user.is_authenticated(): if not current_user.is_admin(): return redirect(url_for('chat.login')) else: return redirect(url_for('chat.login')) return super(CustomAdminIndexView, self).index() def is_accessible(self): if current_user.is_authenticated(): return current_user.is_admin()
# -*- coding: utf-8 -*- from rstextme.main import * from rstextme.models import User from flask.ext.openid import OpenID oid = OpenID(app) def check_form(name, email): if not name: flash(u'Error: you have to provide a name') elif '@' not in email: # TODO: Do this with wtf forms. flash(u'Error: you have to enter a valid email address') else: return True return False @app.before_request def before_request(): g.user = None g.user_is_admin = None if 'openid' in session: g.user = User.query.filter_by(openid=session['openid']).first() @app.after_request def after_request(response): db_session.remove() db_session.commit() return response @app.route('/login', methods=['GET', 'POST']) @app.route('/login', subdomain="<subdomain>", methods=['GET', 'POST']) @oid.loginhandler
import wtforms as wtf import logging import uuid import os app = flask.Flask(__name__) app.config.from_pyfile('config.py') # Set up babel for translations babel = Babel(app) # Set up session secret key app.secret_key = app.config['SESSION_SECRET_KEY'] # Set up OpenID oid = OpenID(app, fs_store_path=app.config['OPENID_STORE'], safe_roots=[]) # Set up MongoDB mongo = PyMongo(app) # Set up logging if not app.debug: file_handler = logging.FileHandler(app.config['LOGFILE']) file_handler.setLevel(logging.DEBUG) app.logger.addHandler(file_handler) @babel.localeselector def get_locale(): return request.accept_languages.best_match(LANGUAGES.keys())
instance_relative_config=True, instance_path=os.environ['WANDER_PATH']) app.config.from_object('wander.app.defaultconfig') app.config.from_pyfile('config.py', silent=True) app.config.from_pyfile('config.cfg', silent=True) app.config.from_envvar('WANDER_CONFIG', silent=True) app.logger.addHandler(handler) Bootstrap(app) admin = Admin(app, name="Wander Admin") db = SQLAlchemy(app) lm = LoginManager() lm.init_app(app) lm.login_view = 'login' oid = OpenID(app, os.path.join(app.config['TMP_DIR'], 'tmp')) def start_jobs(): import wander.worker wander.worker.start() def init_db(): import first_time if os.environ.has_key('WANDER_WIPE'): first_time.purge() try: first_time.create() except DatabaseAlreadyControlledError: pass
from flask.ext.admin import Admin from flask.ext.httpauth import HTTPBasicAuth from flask_debugtoolbar import DebugToolbarExtension auth = HTTPBasicAuth() app = Flask(__name__) # set a 'SECRET_KEY' to enable the Flask session cookies app.config['SECRET_KEY'] = 'sdsdsd' from flask.ext.openid import OpenID j.system.fs.createDir("/var/flash/openid") oid = OpenID(app, '/var/flash/openid', safe_roots=[]) admin = Admin(app) users = {"admin": "admin"} @app.before_request def lookup_current_user(): g.user = None if 'openid' in session: openid = session['openid'] g.user = User.query.filter_by(openid=openid).first() @app.route('/login', methods=['GET', 'POST'])
from config import basedir, ADMINS, MAIL_SERVER, MAIL_PORT, MAIL_USERNAME, MAIL_PASSWORD from momentjs import momentjs from error_log_email import TlsSMTPHandler app = Flask(__name__) app.config.from_object('config') db = SQLAlchemy(app) # set up time formatting app.jinja_env.globals['momentjs'] = momentjs # set up log in system lm = LoginManager() lm.init_app(app) lm.login_view = 'login' oid = OpenID(app, os.path.join(basedir, 'tmp')) # set up email capabilities mail = Mail(app) # set up logging if not app.debug and MAIL_SERVER != '': import logging from logging.handlers import SMTPHandler credentials = None if MAIL_USERNAME or MAIL_PASSWORD: credentials = (MAIL_USERNAME, MAIL_PASSWORD) mail_handler = TlsSMTPHandler((MAIL_SERVER, 587), '*****@*****.**', ADMINS, 'MissionConnect Error!', credentials) mail_handler.setLevel(logging.ERROR)
class GoogleAuth(object): """Google Federated Authentication manager. If ``install==True`` (default), it is automatically installed into the given Flask application. """ def __init__(self, app, install=True, prefix=None, name='GoogleAuth'): self.app = app self.app.config.setdefault('GOOGLE_DOMAIN', None) self.oid = OpenID(self.app) self.url_prefix = prefix self.name = name self.blueprint = self._get_blueprint(self.name) self.domain = self.app.config.get('GOOGLE_DOMAIN') self._login = self.oid.loginhandler(self.__login) self._create_or_login = self.oid.after_login(self.__create_or_login) if install: self.install() def _check_auth(self): """Returns True if authentication is valid.""" return ('openid' in session) if self.domain else True def __login(self): return self.oid.try_login('https://www.google.com/accounts/o8/site-xrds?hd=%s' % self.domain) def _before_request(self): g.user = None def __create_or_login(self, resp): """This is called when login with OpenID succeeded and it's not necessary to figure out if this is the users's first login or not. This function has to redirect otherwise the user will be presented with a terrible URL which we certainly don't want. """ session['openid'] = resp.identity_url return redirect(self.oid.get_next_url()) def _logout(self): session.pop('openid', None) return redirect(self.oid.get_next_url()) def _get_blueprint(self, name): return Blueprint( name, __name__, static_folder=os.path.join(current_dir, 'static'), template_folder=os.path.join(current_dir, 'templates'), ) def _configure_routes(self): self.blueprint.route('/login/', methods=['GET', 'POST'])(self._login) self.blueprint.route('/logout/', methods=['GET', 'POST'])(self._logout) def _register_blueprint(self, **kwargs): self.app.register_blueprint( self.blueprint, url_prefix=self.url_prefix, **kwargs ) def install(self): """Installs the Blueprint into the app.""" self.app.before_request(self._before_request) self._configure_routes() self._register_blueprint() def required(self, f): """Request decorator. Forces authentication.""" @wraps(f) def decorated(*args, **kwargs): auth = request.authorization if not self._check_auth(): return redirect(url_for('%s.__login' % self.blueprint.name, next=request.url)) return f(*args, **kwargs) return decorated