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
