def init_debug_toolbar(self):
if (not self.testing
and self.config.get('DEBUG_TB_ENABLED')
and 'debugtoolbar' not in self.blueprints):
try:
from flask.ext.debugtoolbar import DebugToolbarExtension, DebugToolbar
except ImportError:
logger.warning('DEBUG_TB_ENABLED is on but flask.ext.debugtoolbar '
'is not installed.')
else:
try:
default_config = DebugToolbar.config
init_dbt = DebugToolbarExtension
except AttributeError:
# debugtoolbar > 0.8.0
dbt = DebugToolbarExtension()
default_config = dbt._default_config(self)
init_dbt = dbt.init_app
if not 'DEBUG_TB_PANELS' in self.config:
# add our panels to default ones
self.config['DEBUG_TB_PANELS'] = list(default_config['DEBUG_TB_PANELS'])
self.config['DEBUG_TB_PANELS'].append(
'abilian.services.indexing.debug_toolbar.IndexedTermsDebugPanel'
)
init_dbt(self)
for view_name in self.view_functions:
if view_name.startswith('debugtoolbar.'):
extensions.csrf.exempt(self.view_functions[view_name])
def setUp(self):
app = flask.Flask(__name__)
app.config['MONGODB_DB'] = 'testing'
app.config['TESTING'] = True
app.config['DEBUG_TB_PANELS'] = (
'flaskext.mongoengine.panels.MongoDebugPanel', )
DebugToolbarExtension(app)
db = mongoengine.MongoEngine()
self.Todo = make_todo_model(db)
db.init_app(app)
@app.route('/')
def index():
return '\n'.join(x.title for x in self.Todo.objects)
@app.route('/add', methods=['POST'])
def add():
form = flask.request.form
todo = self.Todo(title=form['title'], text=form['text'])
todo.save()
return 'added'
@app.route('/show/<id>/')
def show(id):
todo = self.Todo.objects.get_or_404(id=id)
return '\n'.join([todo.title, todo.text])
self.app = app
self.db = db
def init_app(app):
init_markdown(app)
from . import helpers, error_handlers
# Load all core views and blueprint
import udata.core.search.views
from udata.core.storages.views import blueprint as storages_blueprint
from udata.core.user.views import blueprint as user_blueprint
from udata.core.site.views import noI18n, blueprint as site_blueprint
from udata.core.dataset.views import blueprint as dataset_blueprint
from udata.core.reuse.views import blueprint as reuse_blueprint
from udata.core.organization.views import blueprint as org_blueprint
from udata.core.followers.views import blueprint as follow_blueprint
from udata.core.topic.views import blueprint as topic_blueprint
from udata.core.post.views import blueprint as post_blueprint
from udata.core.tags.views import bp as tags_blueprint
from udata.admin.views import admin as admin_blueprint
app.register_blueprint(storages_blueprint)
app.register_blueprint(user_blueprint)
app.register_blueprint(noI18n)
app.register_blueprint(site_blueprint)
app.register_blueprint(dataset_blueprint)
app.register_blueprint(reuse_blueprint)
app.register_blueprint(org_blueprint)
app.register_blueprint(follow_blueprint)
app.register_blueprint(topic_blueprint)
app.register_blueprint(post_blueprint)
app.register_blueprint(tags_blueprint)
app.register_blueprint(admin_blueprint)
# Load all plugins views and blueprints
for plugin in app.config['PLUGINS']:
module = 'udata.ext.{0}.views'.format(plugin)
_load_views(app, module)
# Optionnaly register debug views
if app.config.get('DEBUG'):
@front.route('/403/')
def test_403():
abort(403)
@front.route('/404/')
def test_404():
abort(404)
@front.route('/500/')
def test_500():
abort(500)
# Load front only views and helpers
app.register_blueprint(front)
# Load debug toolbar if enabled
if app.config.get('DEBUG_TOOLBAR'):
from flask.ext.debugtoolbar import DebugToolbarExtension
DebugToolbarExtension(app)
def create_app(config_object=None, db_name=None): # pragma: no cover
app_settings = os.getenv('APP_SETTINGS')
from dotenv import load_dotenv
if app_settings:
load_dotenv(app_settings)
else:
load_dotenv('development.env')
app = Flask(__name__, static_url_path=os.environ.get("STATIC_URL"))
if config_object is None:
app.config.from_object('config.BaseConfiguration')
else:
app.config.from_object(config_object)
if not app.logger.handlers:
stream_handler = StreamHandler()
app.logger.addHandler(stream_handler)
if app.debug:
app.logger.setLevel("DEBUG")
app.config["DEBUG_TB_INTERCEPT_REDIRECTS"] = False
app.config["DEBUG_TB_PROFILER_ENABLED"] = \
os.environ.get("PROFILER", "False") == 'True'
app.config['RQ_DEFAULT_URL'] = os.environ.get("REDIS_URL")
else:
app.logger.setLevel("INFO")
RQ(app)
Bootstrap(app)
DebugToolbarExtension(app)
from multivac.views import multivac_bp
app.register_blueprint(multivac_bp)
return app
def configure_extensions(app):
try:
from flask.ext.debugtoolbar import DebugToolbarExtension
# debug toolbar; it's automatically disabled if DEBUG == False
DebugToolbarExtension(app)
except ImportError:
pass
def create_app(config='dev'):
""" Flask application factory
:param str config: type of app to build, either "prod" or "dev"
"""
# Create flask application
app = Flask(__name__)
app.config.from_object('settings')
app.config['ENV'] = config
app.jinja_env.trim_blocks = True
# Debug toolbar (when debug=true)
debug_toolbar = DebugToolbarExtension(app)
app.config['DEBUG_TB_PROFILER_ENABLED'] = True
app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = False
# Register Blueprints
app.register_blueprint(views_base.base)
app.register_blueprint(views_blog.blog)
# Flask-Assets; bundles all css/js files in minifed file
assets = Environment(app)
css_all = Bundle('css/bootstrap-flatly.min.css', 'css/highlightjs.min.css', 'css/font-awesome.css', 'css/main.css',
filters='cssmin', output='gen/style.css')
js_all = Bundle('js/vendor/jquery.min.js', 'js/vendor/bootstrap.min.js', 'js/vendor/showdown-gfm.min.js',
'js/vendor/highlight.min.js', 'js/main.js', filters='jsmin', output='gen/libs.js')
assets.register('css_all', css_all)
assets.register('js_all', js_all)
if app.config['DEBUG']:
assets.debug = True
app.config['ASSETS_DEBUG'] = True
# Set up Flask-User
babel = Babel(app)
db_adapter = SQLAlchemyAdapter(db, User)
user_manager = UserManager(db_adapter, app) # Init Flask-User and bind to app
# Init the cache
cache.init_app(app)
Moment(app) # moment.js
Misaka(app, autolink=True, # Misaka Markdown
fenced_code=True, lax_html=True, strikethrough=True,
superscript=True, tables=True, wrap=True)
# Init Admin page
admin = Admin(app, index_view=AdminMain(endpoint='admin'))
admin.add_view(PostAdminView())
admin.add_view(NewPostView())
admin.add_view(ModelView(Comment, db.session))
static_path = os.path.join(BASE_DIR, 'app', 'static')
admin.add_view(FileAdminView(static_path, '/static/', name='Static Files'))
# Initialize DB
db.init_app(app)
return app
def init_extensions(app):
collect.init_app(app)
# Enable the DebugToolbar
if app.config['DEBUG_TOOLBAR']:
app.config['DEBUG_TB_PANELS'] = [
'flask_debugtoolbar.panels.versions.VersionDebugPanel',
'flask_debugtoolbar.panels.timer.TimerDebugPanel',
'flask_debugtoolbar.panels.headers.HeaderDebugPanel',
'flask_debugtoolbar.panels.request_vars.RequestVarsDebugPanel',
'flask_debugtoolbar.panels.template.TemplateDebugPanel',
'flask_debugtoolbar.panels.sqlalchemy.SQLAlchemyDebugPanel',
'flask_debugtoolbar.panels.logger.LoggingPanel',
'flask_debugtoolbar.panels.profiler.ProfilerDebugPanel',
]
DebugToolbarExtension(app)
def create_app():
app = Flask(__name__)
app.config.from_object("config")
database.init_database(app)
app.toolbar = DebugToolbarExtension(app)
app.babel = Babel(app)
@app.before_request
def before_request():
g.context = {}
# elixir.setup_all()
return app
def init():
"""
Sets up flask application object `app` and returns it.
"""
# Instantiate main app, load configs, register modules, set
# url patterns and return the `app` object.
app = Flask(__name__)
app.config.from_object(settings)
config.app = app
# Init SQLAlchemy wrapper.
config.db = SQLAlchemy(app)
if app.debug:
DebugToolbarExtension(app)
#: Wrap the `app` with `Babel` for i18n.
Babel(app)
config.cache = Cache(app)
app.jinja_env.add_extension(SlimishExtension)
app.jinja_env.slim_debug = app.debug
config.bcrypt = Bcrypt(app)
# Other initializations.
for fn, values in [
(set_middlewares, getattr(settings, 'MIDDLEWARES', None)),
(set_context_processors, getattr(settings, 'CONTEXT_PROCESSORS',
None)),
(set_template_filters, getattr(settings, 'TEMPLATE_FILTERS', None)),
(set_before_handlers, getattr(settings, 'BEFORE_REQUESTS', None)),
(set_after_handlers, getattr(settings, 'AFTER_REQUESTS', None)),
(set_log_handlers, getattr(settings, 'LOG_HANDLERS', None)),
(set_error_handlers, getattr(settings, 'ERROR_HANDLERS', None)),
(set_blueprints, getattr(settings, 'BLUEPRINTS', None))
]:
if values:
fn(app, values)
# Register all js and css files.
assets = Environment(app)
register_assets(app, assets)
# URL rules.
urls.set_urls(app)
return app
def init_app(init=None,
config=None,
pyfile=None,
template_folder='templates',
index=False,
error=True,
is_web=False,
is_api=False):
""" 创建应用 """
app = Flask(__name__, template_folder=template_folder)
if config:
app.config.from_object(config)
if pyfile:
app.config.from_pyfile(pyfile)
ENVVAR = app.config.get('ENVVAR')
if ENVVAR and os.environ.get(ENVVAR):
app.config.from_envvar(app.config['ENVVAR'])
if app.debug:
app.config.setdefault('DEBUG_TB_ENABLED', True)
app.config.setdefault('DEBUG_TB_PANELS', DEBUG_TB_PANELS)
app.config.setdefault('DEBUG_TB_INTERCEPT_REDIRECTS', False)
DebugToolbarExtension(app)
app.config.setdefault('SESSION_REFRESH_EACH_REQUEST', False)
app.is_web = is_web
app.is_api = is_api
app.is_back = os.environ.get('CHIKI_BACK') == 'true'
app.static_folder = app.config.get('STATIC_FOLDER')
app.mail = Mail(app)
def get_data_path(name):
return os.path.abspath(
os.path.join(app.config.get('DATA_FOLDER'), name))
if app.config.get('USER_AGENT_LIMIT'):
@app.before_request
def before_request():
if request.path == current_app.config.get('WEROBOT_ROLE'):
return
if not app.debug and 'micromessenger' not in request.headers[
'User-Agent'].lower():
return error_msg('请用微信客户端扫一扫')
app.get_data_path = get_data_path
init_babel(app)
init_redis(app)
if app.config.get('SESSION_TYPE'):
Session(app)
init_jinja(app)
init_logger(app)
init_oauth(app)
init_page(app)
db.init_app(app)
media.init_app(app)
with app.app_context():
cm.init_app(app)
Choices.init()
if callable(init):
init(app)
@app.context_processor
def context_processor():
return dict(Item=Item, Menu=Menu)
if error:
init_error_handler(app)
if index:
@app.route('/')
def index():
return redirect(app.config.get('INDEX_REDIRECT'))
blueprint = Blueprint('chiki',
__name__,
template_folder=os.path.join(TEMPLATE_ROOT, 'chiki'))
app.register_blueprint(blueprint)
if app.is_back:
@app.route('/chiki_back')
def chiki_back():
return 'true'
with app.app_context():
if hasattr(app, 'user_manager'):
user = um.models.User.objects(id=100000).first()
if not user:
user = um.models.User(id=100000,
phone='13888888888',
password='******',
nickname=app.config.get('SITE_NAME'))
user.save()
if not user.avatar and os.path.exists(
app.get_data_path('imgs/logo.jpg')):
with open(app.get_data_path('imgs/logo.jpg')) as fd:
user.avatar = dict(stream=StringIO(fd.read()),
format='jpg')
user.save()
return app
def init_app(app):
# nav.init_app(app)
# themes.init_themes(app, app_identifier='udata', loaders=[packaged_themes_loader, plugin_theme_loader])
init_markdown(app)
# csrf.init_app(app)
# app.config['STATIC_DIRS'] = app.config.get('STATIC_DIRS', []) + [
# ('fonts', join(ROOT_DIR, 'static', 'bower', 'bootstrap', 'dist', 'fonts')),
# ('fonts', join(ROOT_DIR, 'static', 'bower', 'font-awesome', 'fonts')),
# ]
# app.config['LESS_PATHS'] = app.config.get('LESS_PATHS', []) + [
# 'less',
# 'bower/bootstrap/less',
# 'bower/font-awesome/less',
# 'bower/bootstrap-markdown/less',
# 'bower/selectize/dist/less',
# 'bower/swagger-ui',
# ]
# # Hook into flask security to user themed auth pages
# app.config.setdefault('SECURITY_RENDER', 'udata.frontend.theme:render')
# # Load bundle from yaml file
# assets.from_yaml(resource_stream(__name__, '../static/assets.yaml'))
# if app.config['ASSETS_DEBUG']:
# assets['require-js'].contents += ('js/config.js', 'js/debug.js')
from . import helpers, error_handlers
# Load all core views and blueprint
import udata.core.search.views
from udata.core.storages.views import blueprint as storages_blueprint
from udata.core.user.views import blueprint as user_blueprint
from udata.core.site.views import blueprint as site_blueprint
from udata.core.dataset.views import blueprint as dataset_blueprint
from udata.core.reuse.views import blueprint as reuse_blueprint
from udata.core.organization.views import blueprint as org_blueprint
from udata.core.followers.views import blueprint as follow_blueprint
from udata.core.topic.views import blueprint as topic_blueprint
from udata.core.post.views import blueprint as post_blueprint
from udata.core.tags.views import bp as tags_blueprint
app.register_blueprint(storages_blueprint)
app.register_blueprint(user_blueprint)
app.register_blueprint(site_blueprint)
app.register_blueprint(dataset_blueprint)
app.register_blueprint(reuse_blueprint)
app.register_blueprint(org_blueprint)
app.register_blueprint(follow_blueprint)
app.register_blueprint(topic_blueprint)
app.register_blueprint(post_blueprint)
app.register_blueprint(tags_blueprint)
# Load all plugins views and blueprints
for plugin in app.config['PLUGINS']:
module = 'udata.ext.{0}.views'.format(plugin)
_load_views(app, module)
# # Load all theme assets
# theme.init_app(app)
# Optionnaly register debug views
if app.config.get('DEBUG'):
@front.route('/403/')
def test_403():
abort(403)
@front.route('/404/')
def test_404():
abort(404)
@front.route('/500/')
def test_500():
abort(500)
# Load front only views and helpers
app.register_blueprint(front)
# Load debug toolbar if enabled
if app.config.get('DEBUG_TOOLBAR'):
from flask.ext.debugtoolbar import DebugToolbarExtension
DebugToolbarExtension(app)
import os
import os.path as op
from flask import Flask
from flask.ext.config_helper import Config
from flask.ext.debugtoolbar import DebugToolbarExtension
from flask_admin import Admin
from flask_admin.contrib import sqla
from faas.models import db, Client
CURRENT_DIR = op.abspath(op.dirname(__file__))
TEMPLATE_DIR = op.join(CURRENT_DIR, 'templates')
STATIC_DIR = op.join(CURRENT_DIR, 'static')
debug_toolbar = DebugToolbarExtension()
app = Flask(__name__, template_folder=TEMPLATE_DIR, static_folder=STATIC_DIR)
config = Config()
config.init_app(app)
debug_toolbar.init_app(app)
app.config.from_yaml(config_name=(os.getenv('FLASK_CONFIG') or 'default'),
file_name='app.yml',
search_paths=[op.dirname(op.dirname(app.root_path))])
db.init_app(app)
admin = Admin(app, name='Admin', template_mode='bootstrap3')
from werkzeug.contrib.fixers import ProxyFix
coin = Flask(__name__, instance_relative_config=True) # __name__
coin.wsgi_app = ProxyFix(coin.wsgi_app)
# load the default configuration
coin.config.from_object('config.default')
# load the configuration from the instance folder
coin.config.from_pyfile('config.py')
# load the file specified by the APP_CONFIG_FILE environment variable
# variables defined here will override those in the default configuration
coin.config.from_envvar('APP_CONFIG_FILE', silent=True)
debugger = DebugToolbarExtension(coin)
babel = Babel(coin)
import admin
import security
import api
import views
import mail
# -*- coding: utf-8 -*-
"""
ext
~~~
Good place for pluggable extensions.
"""
from flask.ext.debugtoolbar import DebugToolbarExtension
from flask.ext.login import LoginManager
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.assets import Environment
from flask.ext.mako import MakoTemplates
db = SQLAlchemy()
assets = Environment()
login_manager = LoginManager()
# Almost any modern Flask extension has special init_app()
# method for deferred app binding. But there are a couple of
# popular extensions that no nothing about such use case.
toolbar = lambda app: DebugToolbarExtension(app) # has no init_app()
mako = lambda app: MakoTemplates(app)
def init_app(init=None,
config=None,
pyfile=None,
template_folder='templates',
index=False,
error=True,
is_web=False,
is_api=False):
""" 创建应用 """
app = Flask(__name__, template_folder=template_folder)
if config: app.config.from_object(config)
if pyfile: app.config.from_pyfile(pyfile)
ENVVAR = app.config.get('ENVVAR')
if ENVVAR and os.environ.get(ENVVAR):
app.config.from_envvar(app.config['ENVVAR'])
else:
app.config.setdefault('DEBUG_TB_ENABLED', True)
app.config.setdefault('DEBUG_TB_PANELS', DEBUG_TB_PANELS)
app.config.setdefault('DEBUG_TB_INTERCEPT_REDIRECTS', False)
toolbar = DebugToolbarExtension(app)
app.is_web = is_web
app.is_api = is_api
app.static_folder = app.config.get('STATIC_FOLDER')
app.mail = Mail(app)
def get_data_path(name):
return os.path.abspath(
os.path.join(app.config.get('DATA_FOLDER'), name))
app.get_data_path = get_data_path
init_babel(app)
init_redis(app)
init_jinja(app)
init_logger(app)
init_oauth(app)
if error:
init_error_handler(app)
if callable(init):
init(app)
if index:
@app.route('/')
def index():
return redirect(app.config.get('INDEX_REDIRECT'))
blueprint = Blueprint('chiki',
__name__,
template_folder=os.path.join(TEMPLATE_ROOT, 'chiki'))
app.register_blueprint(blueprint)
if os.environ.get('CHIKI_BACK') == 'true':
@app.route('/chiki_back')
def chiki_back():
return 'true'
return app
def init_app(init=None,
config=None,
pyfile=None,
template_folder='templates',
index=False,
error=True,
is_web=False,
is_api=False,
manager=False):
""" 创建应用 """
app = Flask(__name__, template_folder=template_folder)
if os.environ.get('LOGGER_DEBUG'):
handler = logging.StreamHandler()
handler.setLevel(logging.DEBUG)
handler.setFormatter(logging.Formatter(DEBUG_LOG_FORMAT))
app.logger.addHandler(handler)
app.logger.setLevel(logging.DEBUG)
init_db(db)
if config:
app.config.from_object(config)
if pyfile:
app.config.from_pyfile(pyfile)
ENVVAR = app.config.get('ENVVAR')
if ENVVAR and os.environ.get(ENVVAR):
env = os.environ.get(ENVVAR)
for pyfile in env.split('|'):
if pyfile.startswith('./'):
pyfile = os.path.join(os.getcwd(), pyfile)
app.logger.info('load config pyfile: %s' % pyfile)
app.config.from_pyfile(pyfile)
if app.debug:
app.config.setdefault('DEBUG_TB_ENABLED', True)
app.config.setdefault('DEBUG_TB_PANELS', DEBUG_TB_PANELS)
app.config.setdefault('DEBUG_TB_INTERCEPT_REDIRECTS', False)
DebugToolbarExtension(app)
app.config.setdefault('SESSION_REFRESH_EACH_REQUEST', False)
app.is_web = is_web
app.is_api = is_api
app.is_admin = not is_web and not is_api
app.is_back = os.environ.get('CHIKI_BACK') == 'true'
app.static_folder = app.config.get('STATIC_FOLDER')
app.mail = Mail(app)
def get_data_path(name):
return os.path.abspath(
os.path.join(app.config.get('DATA_FOLDER'), name))
if app.config.get('USER_AGENT_LIMIT', False):
@app.before_request
def before_request():
if request.path == current_app.config.get('WEROBOT_ROLE'):
return
ua = request.headers['User-Agent'].lower()
if not app.debug and 'micromessenger' not in ua:
return error_msg('请用微信客户端扫一扫')
app.get_data_path = get_data_path
init_babel(app)
init_redis(app)
if not app.config.get('CACHE_TYPE'):
app.config['CACHE_TYPE'] = 'simple'
cache.init_app(app)
if app.config.get('SESSION_TYPE'):
Session(app)
init_jinja(app)
init_logger(app)
init_oauth(app)
init_third(app)
init_page(app)
db.init_app(app)
media.init_app(app)
if app.is_admin and not manager:
with app.app_context():
cm.init_app(app)
Choices.init()
global inits
for i in inits:
i(app)
if callable(init):
init(app)
@app.context_processor
def context_processor():
return dict(Item=Item, Menu=Menu, url_for=url_for, ImageItem=ImageItem)
if error:
init_error_handler(app)
if index:
@app.route('/')
def index():
return redirect(app.config.get('INDEX_REDIRECT'))
blueprint = Blueprint('chiki',
__name__,
template_folder=os.path.join(TEMPLATE_ROOT, 'chiki'))
app.register_blueprint(blueprint)
if app.is_back:
@app.route('/chiki_back')
def chiki_back():
return 'true'
if app.is_admin and not manager:
with app.app_context():
if hasattr(app, 'user_manager'):
user = um.models.User.objects(id=100000).first()
if not user:
user = um.models.User(id=100000,
phone='13888888888',
password='******',
nickname=app.config.get('SITE_NAME'))
user.tid = user.create_tid()
user.save()
if not user.avatar and os.path.exists(
app.get_data_path('imgs/logo.jpg')):
with open(app.get_data_path('imgs/logo.jpg')) as fd:
user.avatar = dict(stream=StringIO(fd.read()),
format='jpg')
user.save()
@app.route('/1.gif')
def gif():
return send_file(DATA_ROOT + '/1.gif',
cache_timeout=0,
add_etags=False,
mimetype='image/gif')
@app.route('/test/error')
def test_error():
raise ValueError('testing!!!')
@app.route('/trace/log', methods=['POST'])
def trace_log():
user = None
if current_user.is_authenticated():
user = current_user.id
if current_app.config.get('FAST_MODE') is True:
return json_success()
TraceLog(
user=user,
key=request.form.get('key', ''),
tid=request.form.get('tid', ''),
label=request.form.get('label', ''),
value=request.form.get('value', ''),
).save()
return json_success()
@app.route('/complaint/choose')
@login_required
def complaint_choose():
complaint = sorted(Complaint.TYPE.DICT.iteritems(),
key=lambda x: x[1],
reverse=True)
return render_template('complaint/choose.html', type=complaint)
@app.route('/complaint/desc/')
@login_required
def complaint_desc():
types = request.args.get('type', '')
return render_template('complaint/desc.html', types=types)
@app.route('/complaint/refer', methods=['POST'])
@login_required
def complaint_refer():
types = request.form.get('type', '')
content = request.form.get('content', '')
complaints = Complaint(
user=current_user.id,
content=content,
type=types,
active=True,
)
complaints.create()
complaints.save()
return json_success(msg='success', num=complaints.id)
@app.route('/complaint/save/')
@login_required
def complaint_save():
num = request.args.get('num', '')
return render_template('complaint/refer.html', num=num)
@app.route('/complaint/active')
@login_required
def complaint_active():
complaints = Complaint.objects(user=current_user.id,
active=True).first()
if complaints:
complaints.user.complaint = True
complaints.user.save()
return ''
init_db(db)
return app
def configure_debugtoolbar(app):
DebugToolbarExtension(app)
#coding=utf-8
from flask.ext.cache import Cache
from flask.ext.debugtoolbar import DebugToolbarExtension
from flask.ext.login import LoginManager
from flask_assets import Environment
from appname.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.user_loader
def load_user(userid):
return User.query.get(userid)
def debug_app(app):
toolbar = DebugToolbarExtension()
toolbar.init_app(app)
from Web.rawFlask.settings import create_app, configure_blueprints
from Web.rawFlask import config
from Web.rawFlask.ext import db
__author__ = 'hany'
env = os.getenv('APP_ENV')
if not env:
env = "Development"
cfg = getattr(config, '%sConfig' % env)
if not cfg:
raise RuntimeError("can not find config for Evn %s" % env)
app = create_app(conf=cfg)
app = configure_blueprints(app, MOUNT_POINTS)
toolbar = DebugToolbarExtension(app)
manager = Manager(app)
manager.add_command('runServer', Server(host='0.0.0.0', port=5000))
@app.errorhandler(404)
def not_found(error):
return render_template('common/file_404.html')
@manager.command
def db_setup():
"create all database tables"
db.create_all()
################
#### config ####
################
application = Flask(__name__)
application.config.from_object('config.ProductionConfig')
####################
#### extensions ####
####################
login_manager = LoginManager()
login_manager.init_app(application)
bcrypt = Bcrypt(application)
mail = Mail(application)
toolbar = DebugToolbarExtension(application)
db = SQLAlchemy(application)
####################
#### blueprints ####
####################
with application.app_context():
from main.views import main_blueprint
from user.views import user_blueprint
application.register_blueprint(main_blueprint)
application.register_blueprint(user_blueprint)
####################
#### flask-login ####
####################
