def unauthorized_redirect(app):
lm = LoginManager()
lm.login_view = "login"
lm.setup_app(app)
res = lm.unauthorized()
assert res.headers["Location"] == "/login?next=%2F"
assert LOGIN_MESSAGE in get_flashed_messages()
def create_app():
global app
global db
global login_manager
# Flask
app = Flask(__name__)
app.config.from_object('config.flask_config')
# SQLAlchemy
db = SQLAlchemy(app)
# Login
login_manager = LoginManager(app)
login_manager.login_view = 'users.login'
# Assets
assets = Environment(app)
less = Bundle('less/*.less',
filters='less',
output='css/gen/style.css',
depends='less/*.less')
assets.register('less_all', less)
# Debug
app.config['DEBUG'] = (len(argv) == 2 and argv[1] == 'debug')
@login_manager.user_loader
def load_user(userid):
from models import User
return User.query.get(userid)
register_blueprints(app)
return app, db
def __initLoginManager(self):
login_manager = LoginManager()
login_manager.anonymous_user = SupportUser.Anonymous
login_manager.login_view = '/login'
login_manager.login_message = ''
login_manager.user_loader(loadUserByID)
login_manager.init_app(self)
def create_app():
global db
app = Flask(__name__)
app.config.from_object(wemedia.settings)
db = DB(app)
setup_blueprints(app)
setup_logger(app)
# 登录管理器
login_manager = LoginManager()
login_manager.setup_app(app)
login_manager.login_view = 'Common.login'
login_manager.login_message = u'请登录'
@login_manager.user_loader
def load_user(userid):
from wemedia.common.models import User
user = User.query.get(userid)
return user
return app
def login_message(app):
lm = LoginManager()
lm.login_view = "login"
lm.login_message = u"Log in or the owl will eat you."
lm.setup_app(app)
lm.unauthorized()
assert u"Log in or the owl will eat you." in get_flashed_messages()
def initialise(self):
"""
The application needs initialisation to load the database
connection etc. In previous versions this was done with the
initialisation of the class in the __init__ method. This is
now separated into this function.
"""
#: Check if the secret key is defined, if not raise an
#: exception since it is required
assert self.secret_key, 'Secret Key is not defined in config'
#: Load the cache
self.load_cache()
#: Initialise the CSRF handling
self.csrf_protection = CsrfProtect()
self.csrf_protection.init_app(self)
self.view_functions['static'] = self.send_static_file
# Backend initialisation
self.load_backend()
#: Initialise the login handler
login_manager = LoginManager()
login_manager.user_loader(self._pool.get('nereid.user').load_user)
login_manager.header_loader(
self._pool.get('nereid.user').load_user_from_header
)
login_manager.token_loader(
self._pool.get('nereid.user').load_user_from_token
)
login_manager.unauthorized_handler(
self._pool.get('nereid.user').unauthorized_handler
)
login_manager.login_view = "nereid.website.login"
login_manager.anonymous_user = self._pool.get('nereid.user.anonymous')
login_manager.init_app(self)
self.login_manager = login_manager
# Monkey patch the url_for method from flask-login to use
# the nereid specific url_for
flask.ext.login.url_for = url_for
self.template_context_processors[None].append(
self.get_context_processors()
)
# Add the additional template context processors
self.template_context_processors[None].append(
nereid_default_template_ctx_processor
)
# Add template_filters registered using decorator
for name, function in self.get_template_filters():
self.jinja_env.filters[name] = function
# Finally set the initialised attribute
self.initialised = True
def create_app():
global app
global db
global login_manager
# Flask
app = Flask(__name__,
static_folder='static/dist/',
static_url_path='/static')
app.config.from_object('config.flask_config')
# SQLAlchemy
db = SQLAlchemy(app)
# Login
login_manager = LoginManager(app)
login_manager.login_view = 'users.login'
# Debug
app.config['DEBUG'] = (len(argv) == 2 and argv[1] == 'debug')
@login_manager.user_loader
def load_user(userid):
from models import User
return User.query.get(userid)
from app.models import AnonymousUser
login_manager.anonymous_user = AnonymousUser
register_blueprints(app)
return app, db
def setup_login_manager(app):
""" setup_login_manager::flask.Flask->None
Creates a login manager object and attaches an application
object to it.
Also sets up the login view function to redirect to, and
the user_loader function.
"""
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'facebook.login'
login_manager.login_message_category = 'warning'
@login_manager.user_loader
def load_user(user_id):
try:
# we need a request context for a valid db connection
with current_app.test_request_context('/'):
db = g.db
user = db.session.query(User).filter(User.UUID == user_id).one()
return user
except NoResultFound as e:
current_app.logger.debug(e)
return None
def setup_app(app):
"""Setup login extension."""
app.config.setdefault('CFG_OPENID_AUTHENTICATION', False)
app.config.setdefault('CFG_OAUTH1_AUTHENTICATION', False)
app.config.setdefault('CFG_OAUTH2_AUTHENTICATION', False)
@app.errorhandler(401)
def do_login_first(error=401):
"""Displays login page when user is not authorised."""
if request.is_xhr:
return g._("Authorization failure"), 401
if current_user.is_guest:
flash(g._("Please sign in to continue."), 'info')
else:
flash(g._("Authorization failure."), 'danger')
from invenio.modules.accounts.views.accounts import login
return login(referer=request.url), 401
# Let's create login manager.
_login_manager = LoginManager(app)
_login_manager.login_view = app.config.get('CFG_LOGIN_VIEW',
'webaccount.login')
_login_manager.anonymous_user = UserInfo
_login_manager.unauthorized_handler(do_login_first)
@_login_manager.user_loader
def _load_user(uid):
"""
Function should not raise an exception if uid is not valid
or User was not found in database.
"""
return UserInfo(int(uid))
return app
def _get_login_manager(app):
lm = LoginManager()
lm.anonymous_user = AnonymousUser
lm.login_view = '%s.login' % cv('BLUEPRINT_NAME', app=app)
lm.user_loader(_user_loader)
lm.token_loader(_token_loader)
lm.init_app(app)
return lm
def register_login(app): login_manager = LoginManager() login_manager.login_view = 'account.login' login_manager.init_app(app) @login_manager.user_loader def load_user(user_id): return Account.query.get(user_id)
def init_login(self, app): login_manager = LoginManager(app) login_manager.login_view = self.login_endpoint # User Loader @login_manager.user_loader def load_user(id): return self.get_user(id)
def init_login_manager(app):
login_manager = LoginManager()
login_manager.login_view = "auth.login"
login_manager.setup_app(app)
@login_manager.user_loader
def load_user(userid):
return User(userid)
def configure_identity(app):
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = "account.login"
@login_manager.user_loader
def load_user(userid):
return User.get_by_id(int(userid))
def setup_interactive(app):
lm = LoginManager()
lm.login_view = "login"
lm.user_loader(get_user)
@lm.unauthorized_handler
def unauth():
return "UNAUTHORIZED!"
lm.setup_app(app)
def init_app(self, app, datastore):
"""Initializes the Flask-Security extension for the specified
application and datastore implentation.
:param app: The application.
:param datastore: An instance of a user datastore.
"""
if app is None or datastore is None:
return
# TODO: change blueprint name
blueprint = Blueprint('auth', __name__)
configured = {}
for key, value in default_config.items():
configured[key] = app.config.get(key, value)
app.config.update(configured)
config = app.config
# setup the login manager extension
login_manager = LoginManager()
login_manager.anonymous_user = AnonymousUser
login_manager.login_view = config[LOGIN_VIEW_KEY]
login_manager.setup_app(app)
app.login_manager = login_manager
Provider = get_class_from_config(AUTH_PROVIDER_KEY, config)
Form = get_class_from_config(LOGIN_FORM_KEY, config)
pw_hash = config[PASSWORD_HASH_KEY]
app.pwd_context = CryptContext(schemes=[pw_hash], default=pw_hash)
app.auth_provider = Provider(Form)
app.principal = Principal(app)
from flask.ext import security as s
s.User, s.Role = datastore.get_models()
setattr(app, config[USER_DATASTORE_KEY], datastore)
@identity_loaded.connect_via(app)
def on_identity_loaded(sender, identity):
if hasattr(current_user, 'id'):
identity.provides.add(UserNeed(current_user.id))
for role in current_user.roles:
identity.provides.add(RoleNeed(role.name))
identity.user = current_user
@login_manager.user_loader
def load_user(user_id):
try:
return datastore.with_id(user_id)
except Exception, e:
logger.error('Error getting user: %s' % e)
return None
def unauthorized_callback(app):
lm = LoginManager()
lm.login_view = "login"
@lm.unauthorized_handler
def unauth():
return "UNAUTHORIZED!"
lm.setup_app(app)
assert lm.unauthorized() == "UNAUTHORIZED!"
assert len(get_flashed_messages()) == 0
def init_login():
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'login'
# Create user loader function
@login_manager.user_loader
def load_user(user_id):
return db.session.query(User).get(user_id)
def init_login(app):
login_manager = LoginManager()
login_manager.login_view = 'bp.login'
login_manager.init_app(app)
@login_manager.user_loader
def load_user(user_id):
from models import User
return User.query.get(int(user_id))
def setup_login(app):
from models import User
login_manager = LoginManager()
login_manager.login_view = 'Common.login'
login_manager.init_app(app)
@login_manager.user_loader
def load_user(userid):
return User.query.get(userid)
def init_login():
login_manager = LoginManager()
login_manager.login_view = "/login/"
login_manager.init_app(app)
@login_manager.user_loader
def load_user(user_id):
from lightningwolf_smp.models import User
return db.session.query(User).get(user_id)
def get_login_manager(app):
lm = LoginManager(app)
lm.session_protection = 'strong'
lm.anonymous_user = AnonymousUser
lm.login_view = '/login'
lm.user_loader(load_user)
lm.token_loader(load_token)
lm.init_app(app)
return lm
def configure_login_manager(app):
login_manager = LoginManager()
login_manager.init_app(app)
@login_manager.user_loader
def load_user(userid):
return User.query.get(userid)
login_manager.login_view = "frontend.signin"
def create_app(app, config):
app.config.update(SECRET_KEY=config['key']['SECRET_KEY'], SQLALCHEMY_DATABASE_URI=config['app']['SQLALCHEMY_DATABASE_URI'],
DEBUG=config['app']['DEBUG'])
login_manager = LoginManager()
login_manager.session_protection = config['login_manager']['SESSION_PROTECTION']
login_manager.login_view = config['login_manager']['LOGIN_VIEW']
login_manager.init_app(app)
return login_manager
def get_login_manager(**kwargs):
"""
Constructs and returns an instance of :class:`.LoginManager`. Any keyword
arguments provided will be passed to the constructor of
:class:`LoginManager`
"""
login_view = kwargs.pop("login_view", "/login/")
manager = LoginManager(**kwargs)
manager.login_view = login_view
return manager
def init_login(app):
login_manager = LoginManager()
login_manager.session_protection = 'strong'
login_manager.login_view = 'manage.login'
login_manager.init_app(app)
@login_manager.user_loader
def load_user(user_id):
from app.core.models import User
return User.query.get(int(user_id))
def _get_login_manager(app):
lm = LoginManager()
lm.anonymous_user = AnonymousUser
lm.login_view = '%s.login' % cv('BLUEPRINT_NAME', app=app)
lm.user_loader(_user_loader)
lm.token_loader(_token_loader)
lm.login_message, lm.login_message_category = cv('MSG_LOGIN', app=app)
lm.needs_refresh_message, lm.needs_refresh_message_category = cv('MSG_REFRESH', app=app)
lm.init_app(app)
return lm
def init_login():
from . import models
from .apis import wraps
login_manager = LoginManager()
login_manager.init_app(app)
@login_manager.user_loader
def load_user(user_id):
return wraps(models.User.query.get(user_id))
login_manager.login_view = 'user.login'
def setup_authentication(app):
login_manager = LoginManager()
login_manager.setup_app(app)
login_manager.login_view = '/login'
user_service = UserService()
@login_manager.user_loader
def load_user(userId):
user = user_service.get_user(user_id=userId)
return user
def create_app():
app = Flask(__name__)
# config
if os.getenv('DEV') == 'yes':
app.config.from_object('config.DevelopmentConfig')
app.logger.info("Config: Development")
elif os.getenv('TEST') == 'yes':
app.config.from_object('config.TestConfig')
app.logger.info("Config: Test")
else:
app.config.from_object('config.ProductionConfig')
app.logger.info("Config: Production")
db.init_app(app)
## register views
from views import weight_pages
app.register_blueprint(weight_pages)
@app.context_processor
def context_processor():
"""Add variables to context
"""
if hasattr(current_user, '_user'):
curuser = current_user._user
else:
# if user is not logged in
curuser = ""
return {'today': datetime.date.today,
'user':curuser,
}
app.register_error_handler(401, error401)
app.register_error_handler(404, error404)
app.register_error_handler(500, error500)
app.jinja_env.filters['year'] = format_year
# flask-login
login_manager = LoginManager()
login_manager.setup_app(app)
login_manager.login_view = ".login"
@login_manager.user_loader
def load_user(user):
from models import User
u1 = User.query.get(user)
if u1:
return DbUser(user)
else:
return None
return app
from flask import Flask, redirect, render_template, request
from flask.ext.login import (LoginManager, login_required, login_user,
logout_user)
from osstrends import auth
from osstrends.admin import Admin, LoginForm, ChangePasswordForm
from osstrends.database import MongoDatabase
from osstrends.locations import load_locations
app = Flask(__name__)
app.secret_key = auth.APP_SECRET_KEY
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = "/login"
db = MongoDatabase()
locations = load_locations()
admin = Admin(db)
@app.route("/")
def location_selection():
return render_template("location_selection.html", locations=locations)
@app.route("/about")
def about():
return render_template("about.html")
#!/usr/bin/env python2 # -*- coding:utf-8 -*- import os from flask import Flask from flask.ext.sqlalchemy import SQLAlchemy from flask.ext.login import LoginManager FLASKS_ETTINGS = '../config.py' app = Flask(__name__) app.config.from_pyfile(FLASKS_ETTINGS, silent=False) db = SQLAlchemy(app) lm = LoginManager(app) lm.login_view = '/login'
def init(config):
global app
global babel
global login_manager
global db
global cache
# Main application object
app = Flask(__name__)
if config is None:
parser = ConfigParser.ConfigParser()
parser.readfp(open('/etc/hokuto.cfg'))
conf = parser.items('config')
userconfig = {}
for c in conf:
val = c[1]
if (c[1] == 'True' or c[1] == 'False'):
val = bool(val)
userconfig[c[0].upper().rstrip()] = val
app.config.update(userconfig)
else:
for key in config:
app.config[key] = config[key]
# Load any environment-specific configuration file
if os.environ.get('ONOC_CONFIG') is not None:
app.config.from_envvar('ONOC_CONFIG')
# Logging
logfile = app.config.get('LOGGER_FILE', None)
if logfile is not None:
handler = logging.FileHandler(logfile)
handler.setFormatter(
logging.Formatter('%(asctime)s [%(levelname)s] %(message)s'))
loglevel = parse_logger_level(app.config.get('LOGGER_LEVEL'))
if loglevel is not None:
app.logger.setLevel(loglevel)
handler.level = loglevel
app.logger.addHandler(handler)
app.logger.info('Hokuto is initializing...')
# Caching
# A little bit simplistic for now, we could improve that
cache = SimpleCache()
# SQLAlchemy
db = SQLAlchemy(app)
# Babel
babel = Babel(app)
@babel.localeselector
def babel_locateselector():
# Fall back to configuration
return None
@babel.timezoneselector
def babel_timezoneselector():
#Fall back to configuration
return None
# Livestatus connector
if app.config.get('LIVESTATUS_SOCKET', None) is not None:
livestatus.set_server_address(app.config['LIVESTATUS_SOCKET'])
else:
livestatus.set_server_address(
(app.config.get('LIVESTATUS_HOST', '127.0.0.1'),
int(app.config.get('LIVESTATUS_PORT', 50000))))
# Security session manager
login_manager = LoginManager()
login_manager.init_app(app, add_context_processor=True)
login_manager.login_message = gettext('Please log in to access this page')
login_manager.login_view = 'login'
# A useful route converter that filters a URL using a regular expression
# It can be used like this in a rule : blah/<regex([a-z]):data>
class RegexConverter(BaseConverter):
def __init__(self, map, *items):
super(RegexConverter, self).__init__(map)
self.regex = items[0]
app.url_map.converters['regex'] = RegexConverter
# Assets manager
#assets = Environment(app)
#register_all(app, assets)
# Include views
import user # User management (incl. login)
import grapher # Graph screens (logical & physical)
import dashboard # Dashboard page
import widgetsloader # Dashboard widgets tools
import structureservice
import graphiteservice # Graphites services
import livestatusservice # Livestatus services
import predictservice # predictation tools
import reports # logs screens
import configservice # Shinken configuration web services
#Starting point
@app.route('/')
@login_required
def index():
return render_template('main.html')
init_db(user.User)
app.logger.debug('Initialization successful!')
return app
def init(config):
global app
global babel
global login_manager
global db
# Main application object
app = Flask(__name__)
if config is None:
app.config.from_pyfile('config.cfg')
else:
for key in config:
app.config[key] = config[key]
# Load any environment-specific configuration file
if os.environ.get('ONOC_CONFIG') is not None:
app.config.from_envvar('ONOC_CONFIG')
# Logging
logfile = app.config.get('LOGGING', None)
if logfile is not None:
import logging
handler = logging.FileHandler(logfile)
handler.level = logging.DEBUG
app.logger.addHandler(handler)
# SQLAlchemy
db = SQLAlchemy(app)
# Babel
babel = Babel(app)
@babel.localeselector
def babel_locateselector():
# Fall back to configuration
return None
@babel.timezoneselector
def babel_timezoneselector():
#Fall back to configuration
return None
# Livestatus connector
if app.config.get('LIVESTATUS_SOCKET', None) is not None:
livestatus.set_server_address(app.config['LIVESTATUS_SOCKET'])
else:
livestatus.set_server_address((app.config.get('LIVESTATUS_HOST', '127.0.0.1'),
int(app.config.get('LIVESTATUS_PORT', 50000))))
# Security session manager
login_manager = LoginManager()
login_manager.init_app(app, add_context_processor=True)
login_manager.login_message = gettext('Please log in to access this page')
login_manager.login_view = 'login'
# A useful route converter that filters a URL using a regular expression
# It can be used like this in a rule : blah/<regex([a-z]):data>
class RegexConverter(BaseConverter):
def __init__(self, map, *items):
super(RegexConverter, self).__init__(map)
self.regex = items[0]
app.url_map.converters['regex'] = RegexConverter
# Assets manager
#assets = Environment(app)
#register_all(app, assets)
# Include views
import user # User management (incl. login)
import grapher # Graph screens (logical & physical)
import dashboard # Dashboard page
import widgetsloader # Dashboard widgets tools
import structureservice
import graphiteservice # Graphites services
import livestatusservice # Livestatus services
import predictservice # predictation tools
import reports # logs screens
#Starting point
@app.route('/')
@login_required
def index():
return render_template('main.html')
init_db(user.User)
from flask.ext.login import current_user
from helpers import gravatar
# Initialize the Flask all object
app = Flask(__name__, template_folder='templates', static_folder='static')
# Choose the configuration to load
app.config.from_object(config.Development)
app.config['TEMPLATES_PATH'] = '{0}/templates'.format(
os.path.dirname(__file__))
# Login manager
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = "users.login"
login_manager.login_message = u"Please login."
@login_manager.user_loader
def load_user(userid):
api = Api(endpoint=SystemUtility.attract_server_endpoint(),
username=None,
password=None,
token=userid)
params = {'where': 'token=="{0}"'.format(userid)}
token = Token.all(params, api=api)
if token:
user_id = token['_items'][0]['user']
user = User.find(user_id, api=api)
from flask.ext.mail import Mail
from flask.ext.moment import Moment
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.login import LoginManager
from flask.ext.pagedown import PageDown
from config import config
bootstrap = Bootstrap()
mail = Mail()
moment = Moment()
db = SQLAlchemy()
pagedown = PageDown()
login_manager = LoginManager()
login_manager.session_protection = 'strong' # 设置不同的安全等级防止用户会话被篡改
login_manager.login_view = 'auth.login' # 设置登录页面的端点
def create_app(config_name):
'''
工厂函数， 返回创建的程序实例，定义扩展
保存的配置可使用app.config配置对象提供的from_object()方法直接导入
'''
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
bootstrap.init_app(app)
mail.init_app(app)
moment.init_app(app)
db.init_app(app)
default_timeout=86000)
app.jinja_env.add_extension(FragmentCacheExtension)
#connecting to celery
Celery(app)
#connect to mongohq
db.init_app(app)
#enabling markdown
Markdown(app)
#configuring flask-login
login_manager = LoginManager()
login_manager.setup_app(app)
login_manager.login_view = "other.login_required"
login_manager.session_protection
@login_manager.user_loader
def load_user(user_id):
return User.objects(id=user_id).first()
#jinaj2 global template variables and function
#variables available to jinja2
app.jinja_env.globals['categories'] = categories
app.jinja_env.globals['date_ranges'] = date_ranges
app.jinja_env.globals['sorts'] = sorts
app.jinja_env.globals['user'] = current_user
app.jinja_env.globals['user_history_filters'] = user_history_filters
from flask.ext.bootstrap import Bootstrap
from flask.ext.login import LoginManager
from config import config
from flask.ext.mail import Mail
from flask.ext.moment import Moment
from flask.ext.pagedown import PageDown
mail = Mail()
moment = Moment()
db = SQLAlchemy()
bootstrap = Bootstrap()
pagedown = PageDown()
login_manager = LoginManager()
login_manager.session_protection = 'strong'
login_manager.login_view = 'admin.login'
login_manager.login_message = u'请登录之后再进行操作！'
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
bootstrap.init_app(app)
mail.init_app(app)
moment.init_app(app)
db.init_app(app)
login_manager.init_app(app)
pagedown.init_app(app)
# content = """Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."""
# for i in range(25):
# entry = Entry(
# title="Test Entry #{}".format(i),
# content=content
# )
# db.session.add(entry)
# db.session.commit()
#
# seed()
#------------------------------
# Setting up the login system
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = "login_get"
login_manager.login_message_category = "danger"
@login_manager.user_loader
def load_user(id):
return db.session.query(User).get(int(id))
@app.route('/register')
def register():
db.session.add(User('admin', '*****@*****.**', '123'))
db.session.commit()
return "Register"
from flask.ext.cache import Cache
from flask.ext.debugtoolbar import DebugToolbarExtension
from flask.ext.login import LoginManager
from flask_assets import Environment
from sd5.models import User
# Setup flask cache
cache = Cache()
# init flask assets
assets_env = Environment()
debug_toolbar = DebugToolbarExtension()
login_manager = LoginManager()
login_manager.login_view = "main.login"
login_manager.login_message_category = "warning"
@login_manager.user_loader
def load_user(userid):
return User.query.get(userid)
log_file_path = app.config.get('LOG_FILE')
log_level = app.config.get('LOG_LEVEL', logging.WARN)
if log_file_path: # pragma: no cover
file_handler = RotatingFileHandler(log_file_path)
file_handler.setFormatter(
Formatter('%(name)s:%(levelname)s:[%(asctime)s] %(message)s '
'[in %(pathname)s:%(lineno)d]'))
file_handler.setLevel(log_level)
app.logger.addHandler(file_handler)
logger = logging.getLogger('pybossa')
logger.setLevel(log_level)
logger.addHandler(file_handler)
login_manager = LoginManager()
login_manager.login_view = 'account.signin'
login_manager.login_message = u"Please sign in to access this page."
# Configure theme
try: # pragma: no cover
# First with local settings
import settings_local
theme = settings_local.THEME
except:
# Otherwise try with default theme
theme = settings.THEME
# Create app
app = create_app(theme=theme)
sentinel = Sentinel(app.config['REDIS_SENTINEL'], socket_timeout=0.1)
redis_master = sentinel.master_for('mymaster')
redis_slave = sentinel.slave_for('mymaster')
#!venv/bin/python
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.script import Manager
from flask.ext.migrate import Migrate, MigrateCommand
from flask.ext.login import LoginManager
import logging
from twilio.rest import TwilioRestClient
# Creates global Flask app object
# Sets configuration variables from config.py
app = Flask(__name__)
app.config.from_pyfile('../config.py')
# Creates global SQLAlchemy and Migrate objects
db = SQLAlchemy(app)
migrate = Migrate(app, db)
# Creates global Manager object and allows migrate.py to work
manager = Manager(app)
manager.add_command('db', MigrateCommand)
lm = LoginManager(app)
lm.login_view = 'home'
#Twilio text client
textClient = TwilioRestClient(app.config["ACCOUNT_SID"],
app.config["AUTH_TOKEN"])
from alert import views, models
login_manager = LoginManager()
import pwdmanager
from pwdmanager import LmfdbUser, LmfdbAnonymousUser
base_url = "http://beta.lmfdb.org"
@login_manager.user_loader
def load_user(userid):
from pwdmanager import LmfdbUser
return LmfdbUser(userid)
login_manager.login_view = "users.info"
# this anonymous user has the is_admin() method
login_manager.anonymous_user = LmfdbAnonymousUser
def get_username(uid):
"""returns the name of user @uid"""
return LmfdbUser(uid).name
# globally define user properties and username
@app.context_processor
def ctx_proc_userdata():
app.register_blueprint(answer.mod)
app.register_blueprint(tag.mod)
app.register_blueprint(search.mod)
app.register_blueprint(follow.mod)
app.register_blueprint(remind.mod)
app.register_blueprint(admin.mod)
app.register_blueprint(resource.mod)
#
# Login
#
from odd.biz.user import get_user_by_id
login_manager = LoginManager()
login_manager.setup_app(app)
login_manager.login_view = "general.login"
login_manager.login_message = u"这个页面需要登录后才能访问"
@login_manager.user_loader
def load_user(user_id):
return get_user_by_id(user_id)
@app.errorhandler(404)
def not_found(error):
return render_template('404.html'), 404
@app.errorhandler(413)
def too_large(error):
return render_template('413.html'), 413
# -*- coding: utf-8 -*- from flask.ext.sqlalchemy import SQLAlchemy db = SQLAlchemy() from flask.ext.login import LoginManager login_manager = LoginManager() login_manager.login_view = 'pages.index'
from flask.ext.moment import Moment
from flask.ext.sqlalchemy import SQLAlchemy
from config import config
from flask.ext.login import LoginManager
from flask.ext.pagedown import PageDown
'''
This constructor imports most Flask extension currently in use, without intializing them with any application instance...
'''
bootstrap = Bootstrap()
mail = Mail()
moment = Moment()
db = SQLAlchemy()
pagedown = PageDown()
login_manager = LoginManager()
login_manager.session_protection = 'strong'
login_manager.login_view = 'auth.login'
'''this is an application factory which takes as an argument the application config to be used...'''
def create_app(config_name):
# config_name = 'default'
app = Flask(__name__)
print config_name
'''first config is module and second one is dict
This(config['config_name') dict return a class-name as class-OBJ{obj created by from_object} and its variable... '''
app.config.from_object(config[config_name])
# class-name.method_name b'coz init_app is a @staticmethod
config[config_name].init_app(app)
'''intializing the extenisons'''
# # https://github.com/kamens/gae_mini_profiler
# app.wsgi_app = DebuggedApplication(app.wsgi_app, evalex=True)
#
# from lib.gae_mini_profiler import profiler, templatetags
#
# @app.context_processor
# def inject_profiler():
# return dict(profiler_includes=templatetags.profiler_includes())
# app.wsgi_app = profiler.ProfilerWSGIMiddleware(app.wsgi_app)
else:
app.config.from_object('application.settings.Production')
# Enable jinja2 loop controls extension
app.jinja_env.add_extension('jinja2.ext.loopcontrols')
APP_ROOT = os.path.dirname(
os.path.abspath(__file__)) # refers to application_top
APP_STATIC = os.path.join(APP_ROOT, 'static')
# app.permanent_session_lifetime = timedelta(seconds=1200)
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'home'
# function for jinja2
import function
# Pull in URL dispatch routes
import urls
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.login import LoginManager
from flask.ext.mail import Mail
import os
basedir = os.path.abspath(os.path.dirname(__file__))
app = Flask(__name__, static_folder=basedir + '/static')
app.config.from_object('config')
db = SQLAlchemy(app)
lm = LoginManager()
lm.init_app(app)
lm.login_view = 'login'
mail = Mail(app)
from app import views, models
if not app.debug:
import logging
from logging import FileHandler
file_handler = FileHandler("/var/log/flask/errorlog.txt")
file_handler.setLevel(logging.WARNING)
app.logger.addHandler(file_handler)
SQLALCHEMY_DATABASE_URI = 'sqlite:///../' + SQLALCHEMY_DATABASE_FILE
SECRET_KEY = 'let our bot get you drunk!'
STATIC_PATH = "/static"
STATIC_FOLDER = "content/static"
TEMPLATE_FOLDER = "content/templates"
app = Flask(__name__,
static_url_path=STATIC_PATH,
static_folder=os.path.join("..", STATIC_FOLDER),
template_folder=os.path.join("..", TEMPLATE_FOLDER))
app.config.from_object(__name__)
db = SQLAlchemy(app)
login_manager = LoginManager()
login_manager.login_view = "/admin/login"
login_manager.setup_app(app)
# Import models
from bartendro.model.drink import Drink
from bartendro.model.custom_drink import CustomDrink
from bartendro.model.drink_name import DrinkName
from bartendro.model.drink_booze import DrinkBooze
from bartendro.model.booze import Booze
from bartendro.model.booze_group import BoozeGroup
from bartendro.model.booze_group_booze import BoozeGroupBooze
from bartendro.model.dispenser import Dispenser
from bartendro.model.drink_log import DrinkLog
from bartendro.model.shot_log import ShotLog
# Mettre en place le serveur email
from flask.ext.mail import Mail
mail = Mail(app)
# Mettre en place l'outil pour générer des clés secrètes
from flask.ext.bcrypt import Bcrypt
bcrypt = Bcrypt(app)
# Ajouter une interface administrateur
from flask_admin import Admin
admin = Admin(app, name='Admin', template_mode='bootstrap3')
# Importer les vues
from app.vues import principal, utilisateur, erreur, admin, api
app.register_blueprint(utilisateur.utilisateurbp)
app.register_blueprint(api.apibp)
# Mettre en place la gestion de compte utilisateur
from flask.ext.login import LoginManager
from app.modeles import Utilisateur
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'utilisateurbp.connexion'
@login_manager.user_loader
def load_user(telephone):
return Utilisateur.query.filter(Utilisateur.telephone == telephone).first()
"config.py or user_config.py in your content directory.")
exit(1)
app.config['CONTENT_DIR'] = 'content'
app.config['TITLE'] = 'wiki'
app.config['TITLELNK'] = []
app.config.from_pyfile(
os.path.join(app.config.get('CONTENT_DIR'), config_filename))
manager = Manager(app)
loginmanager = LoginManager()
loginmanager.init_app(app)
loginmanager.login_view = 'user_login'
wiki = Wiki(app.config.get('CONTENT_DIR'))
users = UserManager(app.config.get('USER_CONFIG_DIR'))
if not os.path.exists(app.config.get('UPLOAD_DIR')):
os.makedirs(app.config.get('UPLOAD_DIR'))
@loginmanager.user_loader
def load_user(name):
return users.get_user(name)
@app.route('/')
if app.config['WARNING_LOG']:
warning_fh = RotatingFileHandler(app.config['WARNING_LOG'],
maxBytes=1024 * 1024 * 10,
backupCount=10,
encoding='utf_8')
warning_fh.setLevel(logging.WARNING)
app.logger.addHandler(warning_fh)
class User(UserMixin):
def __init__(self, id):
self.id = id
login_manager = LoginManager()
login_manager.login_view = "ui.login"
@login_manager.user_loader
def load_user(username):
return User(username)
login_manager.setup_app(app, add_context_processor=True)
es = ElasticSearch(app.config['ELASTICSEARCH_ENDPOINT'],
max_retries=2,
timeout=10,
revival_delay=0)
import geordi.views
from redis import Redis
import urlparse
from momentjs import momentjs
# Initialize Flask app
app = Flask(__name__)
app.config.from_object('config')
# Variable represents sqlalchemy
db = SQLAlchemy(app)
# Initial redis instance - local vs heroku
if os.environ.get('REDISCLOUD_URL') is None:
redis_db = Redis()
else:
url = urlparse.urlparse(os.environ.get('REDISCLOUD_URL'))
redis_db = Redis(host=url.hostname, port=url.port, password=url.password)
# Login information
login_manager = LoginManager()
login_manager.init_app(app)
# Redirect non-loggedin users to login screen
login_manager.login_view = "login" # result if user not logged in
login_manager.login_message = u"Login to customize your weather view."
# Hook up momentjs to jinja
app.jinja_env.globals['momentjs'] = momentjs
from app import views, models
#!venv/bin/python
from flask import Flask, render_template
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.script import Manager
from flask.ext.migrate import Migrate, MigrateCommand
from flask.ext.login import LoginManager
from flask_mail import Mail
app = Flask(__name__)
app.config.from_pyfile('../config.py')
db = SQLAlchemy(app)
migrate = Migrate(app, db)
manager = Manager(app)
manager.add_command('db', MigrateCommand)
lm = LoginManager(app)
lm.login_view = 'index'
mail = Mail(app)
from views import *
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.admin import Admin
from flask.ext.login import LoginManager
from admin import MyView, MyModel, AuthenticatedMenuLink
app = Flask(__name__)
app.config.from_object('config')
login_manager = LoginManager()
login_manager.init_app(app)
db = SQLAlchemy(app)
admin = Admin(app)
admin.add_view(MyView(name='Index'))
login_manager.login_view = 'users.login'
from models import Post, User
admin.add_view(MyModel(Post, db.session))
admin.add_link(AuthenticatedMenuLink(name='Logout', endpoint='users.logout'))
from project.users.views import users_blueprint
from project.posts.views import posts_blueprint
#register blueprints
app.register_blueprint(users_blueprint)
app.register_blueprint(posts_blueprint)
from flask.ext.bcrypt import Bcrypt
bcrypt = Bcrypt(app)
# Import the views
from app.views import main, user, error
app.register_blueprint(user.userbp)
# Setup the user login process
from flask.ext.login import LoginManager
from app.models import User
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'userbp.signin'
@login_manager.user_loader
def load_user(email):
return User.query.filter(User.email == email).first()
# Setup the admin interface
from flask import request, Response
from werkzeug.exceptions import HTTPException
from flask_admin import Admin, expose, BaseView
from flask.ext.admin.contrib.sqla import ModelView
from flask.ext.login import LoginManager
from flask.ext.admin.contrib.fileadmin import FileAdmin
# -*- coding=utf-8 -*-
from flask import Flask, session
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.bootstrap import Bootstrap
from flask.ext.login import LoginManager
from config import config
db = SQLAlchemy()
bootstrap = Bootstrap()
login_manager = LoginManager() #实例化对象
# login_manager.session_protection = 'strong' #设置flask-login session等级
login_manager.login_view = 'admin.login' #如果未登入转跳到指定方法
login_manager.login_message = u'please login first' #未登入提示语
def create_app(config_name):
"""
binding extensions to app
regist blue prients
"""
app = Flask(__name__, template_folder='templates')
app.config.from_object(config[config_name])
# config[config_name].init_app(app)
db.init_app(app)
with app.app_context():
db.create_all()
# Extensions like Flask-SQLAlchemy now know what the "current" app
from flask import Flask
from flask import render_template
from flask.ext.login import LoginManager
'''
@author: Anant Bhardwaj
@date: Sep 19, 2015
'''
##### Create the app #####
app = Flask(__name__)
##### Login Manager #####
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = '/account/login'
@app.route("/")
def hello():
return render_template('/account/login.html')
app.config['MYSQL_DATABASE_PASSWORD'] = MYSQL_DATABASE_PASSWORD app.config['MYSQL_DATABASE_DB'] = MYSQL_DATABASE_DB app.config['MYSQL_DATABASE_HOST'] = MYSQL_DATABASE_HOST mysql.init_app(app) #Bcrypt Config bcrypt = Bcrypt(app) # #LoginManager Instansiated login_manager = LoginManager() # #LoginManager Initialized login_manager.init_app(app) login_manager.login_view = 'login' # Twilio Credentials(Temp) TWILIO_ACCOUNT_SID = 'ACd1e13b7f6f530d73dd47f13ce91224d5' TWILIO_AUTH_TOKEN = '67b23de6936fea29f8982a341276c070' # Twilio Client Object twilio_client = TwilioRestClient(TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN) # MailGun Credentials MG_BASE_URL = 'https://api.mailgun.net/v3/mg.highlandsenergy.com/messages' MG_API_KEY = 'key-bd7254f9d0a6d6ea5c74bd6fcdd4dc72' # SoCal Gas Email
# -*- coding: utf-8 -*-
from flask import render_template, redirect, url_for, request
from flask.ext.login import login_required, login_user, logout_user, LoginManager
from oleander import app, db
from oleander.forms import SignUpForm, SignInForm
from oleander.models import User
login_manager = LoginManager()
login_manager.setup_app(app)
login_manager.login_view = app.config['LOGIN_VIEW']
login_manager.refresh_view = app.config['LOGIN_VIEW']
@login_manager.user_loader
def load_user(user_id):
"""User loader used by sign-in process."""
return User.query.filter_by(id=user_id).first()
@app.route('/sign-up/', methods=('GET', 'POST'))
def sign_up():
"""Registration form."""
form = SignUpForm()
if form.validate_on_submit():
user = User.fetch_by_email(form.primary_email.data)
if user:
form.add_error('email', 'User with such e-mail address already exists.')
