def test_admin(app):
"""Test flask-admin interace."""
InvenioOAuthClient(app)
assert isinstance(remote_account_adminview, dict)
assert isinstance(remote_token_adminview, dict)
assert 'model' in remote_account_adminview
assert 'modelview' in remote_account_adminview
assert 'model' in remote_token_adminview
assert 'modelview' in remote_token_adminview
admin = Admin(app, name='Test')
user_model = remote_account_adminview.pop('model')
user_view = remote_account_adminview.pop('modelview')
admin.add_view(user_view(user_model, db.session,
**remote_account_adminview))
with app.app_context():
# create user and save url for testing
request_url = url_for('remoteaccount.index_view')
with app.app_context():
with app.test_client() as client:
res = client.get(
request_url,
follow_redirects=True
)
assert res.status_code == 200
assert 'Extra Data' in str(res.get_data())
assert 'Tokens' in str(res.get_data())
def get_app(database_uri,
exclude_tables=None,
user_models=None,
reflect_all=True,
read_only=False):
"""Return an application instance connected to the database described in
*database_uri*.
:param str database_uri: The URI connection string for the database
:param list exclude_tables: A list of tables to exclude from the API
service
:param list user_models: A list of user-defined models to include in the
API service
:param bool reflect_all: Include all database tables in the API service
:param bool read_only: Only allow HTTP GET commands for all endpoints
"""
app = Flask('sandman2')
app.config['SQLALCHEMY_DATABASE_URI'] = database_uri
app.config['SANDMAN2_READ_ONLY'] = read_only
db.init_app(app)
admin = Admin(app, base_template='layout.html', template_mode='bootstrap3')
_register_error_handlers(app)
if user_models:
with app.app_context():
_register_user_models(user_models, admin)
elif reflect_all:
with app.app_context():
_reflect_all(exclude_tables, admin, read_only)
return app
def create_admin(app=None):
admin = Admin(app,
name="CleanBlogAdmin",
index_view=MyIndexView(),
base_template='admin/my_master.html')
admin.add_view(UserView(User))
admin.add_view(PostView(Post))
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
loginManager.init_app(app)
db.init_app(app)
moment.init_app(app)
bootstrap.init_app(app)
#Blueprint
from main import main
app.register_blueprint(main)
#admin
from app.admins.adminViews import MyIndexView, PostView, UserView, FriendLinkView, TagView, CategoryView
from app.models import User, Article, FriendLink, Tag, Category
admin = Admin(app=app,
template_mode='bootstrap3',
name='Hei',
endpoint='admin',
index_view=MyIndexView())
admin.add_view(PostView(Article, db.session, name=u'文章管理'))
admin.add_view(FriendLinkView(FriendLink, db.session, name=u'友情链接'))
admin.add_view(TagView(Tag, db.session, name=u'标签管理'))
admin.add_view(CategoryView(Category, db.session, name=u'分类管理'))
return app
def register_classes_for_admin(db_session, show_pks=True, name='admin'):
"""Registers classes for the Admin view that ultimately creates the admin
interface.
:param db_session: handle to database session
:param list classes: list of classes to register with the admin
:param bool show_pks: show primary key columns in the admin?
"""
with app.app_context():
admin_view = Admin(current_app, name=name)
for cls in set(cls for cls in current_app.class_references.values()
if cls.use_admin):
column_list = [
column.name for column in cls.__table__.columns.values()
]
if hasattr(cls, '__view__'):
# allow ability for model classes to specify model views
admin_view_class = type('AdminView', (cls.__view__, ),
{'form_columns': column_list})
elif show_pks:
# the default of Flask-SQLAlchemy is to not show primary
# classes, which obviously isn't acceptable in some cases
admin_view_class = type('AdminView', (AdminModelViewWithPK, ),
{'form_columns': column_list})
else:
admin_view_class = ModelView
admin_view.add_view(admin_view_class(cls, db_session))
def configure_extensions(app):
# configure extensions
# sqlalchemy
db.init_app(app)
db_ean.init_app(app)
# mail
mail.init_app(app)
# cache
cache.init_app(app)
# babel
babel = Babel(app)
# login
login_manager.login_view = 'frontend.login'
login_manager.refresh_view = 'frontend.reauth'
@login_manager.user_loader
def load_user(id):
return User.query.get(int(id))
login_manager.setup_app(app)
# security and Social
app.flask_security = Security(app, SQLAlchemyUserDatastore(db, User, Role))
#app.flask_social = Social(app, SQLAlchemyConnectionDatastore(db, Connection))
# admin
admin = Admin(app)
#admin.add_view(ModelView(GenomeRule, db.session))
admin.add_view(GenomeRuleView(db.session, name="Genome Rules"))
admin.add_view(GenomeCategoryView(db.session, name="Genome Categories"))
def test_admin(app):
"""Test flask-admin interace."""
InvenioUserProfiles(app)
assert isinstance(user_profile_adminview, dict)
assert 'model' in user_profile_adminview
assert 'modelview' in user_profile_adminview
admin = Admin(app, name="Test")
user_model = user_profile_adminview.pop('model')
user_view = user_profile_adminview.pop('modelview')
admin.add_view(user_view(user_model, db.session,
**user_profile_adminview))
with app.test_request_context():
request_url = url_for('userprofile.index_view')
with app.app_context():
with app.test_client() as client:
res = client.get(
request_url,
follow_redirects=True
)
assert res.status_code == 200
assert b'Display Name' in (res.get_data())
assert b'Full Name' in (res.get_data())
def create_app(name, config_filename):
app = Flask(name,
template_folder='app/templates',
static_folder='app/static')
app.config.from_pyfile(config_filename)
from app.models import db
db.init_app(app)
db.app = app
from app.sms import mail
mail.init_app(app)
mail.app = app
from app.views import main
app.register_blueprint(main)
#TODO: Secure admin view
admin = Admin()
admin.init_app(app)
admin.app = app
admin.add_view(ModelView(User, db.session))
if not (app.debug or app.config.get('LOGGING_DISABLE', False)):
import logging
from logging import Formatter
from logging.handlers import SMTPHandler, RotatingFileHandler
mail_handler = SMTPHandler(mailhost=app.config['MAIL_SERVER'],
fromaddr=app.config['LOGGING_SENDER'],
toaddrs=app.config['ADMINS'],
subject='dci-notify Server Error',
credentials=(app.config['MAIL_USERNAME'],
app.config['MAIL_PASSWORD']))
file_handler = RotatingFileHandler(filename=os.path.join(
basedir, 'app.log'),
maxBytes=1048756,
backupCount=5)
mail_handler.setLevel(logging.ERROR)
file_handler.setLevel(logging.WARNING)
mail_handler.setFormatter(
Formatter('''
Message type: %(levelname)s
Location: %(pathname)s:%(lineno)d
Module: %(module)s
Function: %(funcName)s
Time: %(asctime)s
Message:
%(message)s
'''))
file_handler.setFormatter(
Formatter('%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]'))
app.logger.addHandler(mail_handler)
app.logger.addHandler(file_handler)
return app
def init_app():
"""
Factory function to init Flask applictaion.
"""
# Init Flask application and necessary extensions
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite://'
admin = Admin(app)
db = SQLAlchemy(app)
# Add url rules to application
views = LazyViews(app)
views.add('/', 'views.home')
views.add('/db', 'views.database_page')
views.add('/error', 'views.server_error')
views.add('/page/<int:page_id>', 'views.page', endpoint='flatpage')
views.add('/page/<int:page_id>/cls',
'views.PageView',
endpoint='flatpage_cls')
views.add_admin('admin.AdminView', endpoint='app_admin', name='App View')
views.add_error(404, 'views.error')
views.add_error(500, 'views.error')
views.add_static('/favicon.ico',
defaults={'filename': 'img/favicon.ico'},
endpoint='favicon')
# Register test blueprint
app.register_blueprint(test_blueprint, url_prefix='/test')
return (app, admin, db)
def init_admin(self, index_view=None):
from .. import db
from ..models import User, Role
from ..views import AdminIndex, UserAdmin, RoleAdmin, public_blueprint
admin = Admin(
name=self.app.config['PROJECT_NAME'] or 'Admin',
base_template='admin/extended_base.html',
index_view=index_view or AdminIndex(url='/admin'),
template_mode='bootstrap3'
)
admin.init_app(self.app)
admin.add_view(UserAdmin(User, db.session, name='用户管理', category='系统管理'))
admin.add_view(RoleAdmin(Role, db.session, name='角色管理', category='系统管理'))
with self.app.app_context():
@_security.context_processor
def security_context_processor():
return dict(
admin_base_template=admin.base_template,
admin_view=admin.index_view,
h=admin_helpers,
)
@public_blueprint.context_processor
def public_context_processor():
return dict(
admin_base_template=admin.base_template,
admin_view=admin.index_view,
h=admin_helpers,
)
return admin
def activate(admin=True):
"""Activate each registered model for non-admin use"""
with app.app_context():
if getattr(current_app, 'endpoint_classes', None) is None:
current_app.endpoint_classes = {}
current_app.classes_by_name = {}
current_app.table_to_endpoint = {}
current_app.classes = []
if not current_app.endpoint_classes:
db.metadata.reflect(bind=db.engine)
for name, table in db.metadata.tables.items():
try:
cls = type(str(name), (sandman_model, db.Model),
{'__tablename__': name})
register(cls)
except:
print name + ' unable to be registered'
else:
Model.prepare(db.engine)
if admin:
_prepare_relationships()
admin = Admin(app)
with app.app_context():
for cls in (cls for cls in current_app.classes
if cls.use_admin == True):
admin.add_view(ModelView(cls, db.session))
webbrowser.open('http://localhost:5000/admin')
def create_app(config_file):
from models import db
import models
app = Flask(__name__)
app.config.from_object(config_file)
app.url_map.default_subdomain = "media"
app.register_blueprint(media)
app.register_blueprint(api_home)
app.register_blueprint(api_1_0)
db.init_app(app)
admin = Admin(app, name='TheMetaCity Media')
admin.add_view(ModelView(models.MediaItem, db.session, 'Media Items'))
admin.add_view(ModelView(models.VideoFile, db.session, 'Video Files'))
admin.add_view(ModelView(models.VideoTrack, db.session, 'Video Tracks'))
admin.add_view(ModelView(models.Video, db.session, 'Video'))
admin.add_view(ModelView(models.AudioFile, db.session, 'Audio Files'))
admin.add_view(ModelView(models.AudioTrack, db.session, 'Audio Tracks'))
admin.add_view(ModelView(models.Audio, db.session, 'Audio'))
admin.add_view(ModelView(models.Picture, db.session, 'Pictures'))
admin.add_view(ModelView(models.Tags, db.session, 'Tags'))
admin.add_view(ModelView(models.Code, db.session, 'Code'))
admin.add_view(ModelView(models.Postcards, db.session, 'Postcards'))
admin.add_view(ModelView(models.Licence, db.session, 'Licences'))
return app
def test_admin(models_fixture):
"""Test flask-admin interface."""
app = models_fixture
InvenioOAuth2Server(app)
assert isinstance(oauth2server_tokens_adminview, dict)
assert isinstance(oauth2server_clients_adminview, dict)
assert 'view_class' in oauth2server_tokens_adminview
assert 'view_class' in oauth2server_clients_adminview
admin = Admin(app, name="Test")
clients_view = oauth2server_clients_adminview.pop('view_class')
clients_model, clients_session = oauth2server_clients_adminview.pop('args')
clients_kwargs = oauth2server_clients_adminview.pop('kwargs')
tokens_view = oauth2server_tokens_adminview.pop('view_class')
tokens_model, tokens_session = oauth2server_tokens_adminview.pop('args')
tokens_kwargs = oauth2server_tokens_adminview.pop('kwargs')
admin.add_view(clients_view(clients_model, db.session, **clients_kwargs))
admin.add_view(tokens_view(tokens_model, db.session, **tokens_kwargs))
menu_items = {str(item.name): item for item in admin.menu()}
assert 'User Management' in menu_items
assert menu_items['User Management'].is_category()
submenu_items = {
str(item.name): item
for item in menu_items['User Management'].get_children()
}
assert 'OAuth Applications' in submenu_items
assert 'OAuth Application Tokens' in submenu_items
with app.test_request_context():
token_request_url = url_for('token.index_view')
client_request_url = url_for('client.index_view')
client_view_url = url_for('invenio_oauth2server_settings.client_view',
client_id='client_test_u1c1')
client_reset_url = url_for(
'invenio_oauth2server_settings.client_reset',
client_id='client_test_u1c1')
token_view_url = url_for('invenio_oauth2server_settings.token_view',
token_id='1')
token_revoke_url = url_for(
'invenio_oauth2server_settings.token_revoke', token_id='1')
with app.app_context():
with app.test_client() as client:
res = client.get(token_request_url, follow_redirects=True)
assert res.status_code == 200
res = client.get(client_request_url, follow_redirects=True)
assert res.status_code == 200
res = client.get(client_view_url, follow_redirects=True)
assert res.status_code == 200
res = client.post(client_reset_url, follow_redirects=True)
assert res.status_code == 200
res = client.get(token_view_url, follow_redirects=True)
assert res.status_code == 200
res = client.post(token_revoke_url, follow_redirects=True)
assert res.status_code == 405
def create_app(name=None, **options):
"""
Factory function to create Flask applictaion.
"""
# Init Flask application and configure it
app = Flask(name or __name__)
app.config.update({'DEBUG': True, 'SQLALCHEMY_DATABASE_URI': 'sqlite://'})
app.config.update(options)
# Setup necessary extensions
Admin(app), SQLAlchemy(app)
# Add lazy views to application
views = LazyViews(app, 'testapp')
views.add('/', 'views.home')
views.add('/db', 'views.database_page', endpoint='dbpage')
views.add('/error', 'views.server_error')
views.add('/error/default', 'views.custom_error', defaults={'code': 400})
views.add('/error/<int:code>', 'views.custom_error')
views.add('/gone',
'views.custom_error',
defaults={'code': 410},
endpoint='gone')
views.add('/page/<int:page_id>', 'views.page', endpoint='flatpage')
views.add('/page/<int:page_id>/cls',
'views.PageView',
endpoint='flatpage_cls')
# Admin view
views.add_admin('admin.AdminView',
endpoint='app_admin',
name='Custom Admin Page')
# Error handlers
views.add_error(404, 'views.error')
views.add_error(500, 'views.error')
# Custom static file serving
views.add_static('/favicon.ico', 'img/favicon.ico', endpoint='favicon')
views.add_static('/old-favicon.ico',
defaults={'filename': 'img/favicon.ico'},
endpoint='old_favicon')
# Render templates with dict/callable context or without any context
views.add_template('/template',
'template.html',
context={'text': 'Test Text'},
endpoint='template')
views.add_template('/template/callable-context',
'template.html',
context=lambda: {'text': 'Callable Test Text'},
endpoint='template_callable_context')
views.add_template('/template/no-context',
'template.html',
endpoint='template_no_context')
# Create and register test blueprint
app.register_blueprint(create_blueprint(), url_prefix='/test')
return app
def setup():
app = Flask(__name__)
app.config['CSRF_ENABLED'] = False
app.secret_key = '1'
admin = Admin(app)
return app, admin
def setup():
app = Flask(__name__)
app.config['SECRET_KEY'] = '1'
app.config['CSRF_ENABLED'] = False
admin = Admin(app)
return app, admin
def get_app(database_uri,
exclude_tables=None,
user_models=None,
reflect_all=True):
"""Return an application instance connected to the database described in
*database_uri*.
:param str database_uri: The URI connection string for the database
:param list exclude_tables: A list of tables to exclude from the API
service
:param list user_models: A list of user-defined models to include in the
API service
:param bool reflect_all: Include all database tables in the API service
"""
app = Flask('sandman2')
app.config['SQLALCHEMY_DATABASE_URI'] = database_uri
db.init_app(app)
admin = Admin(app, base_template='layout.html')
_register_error_handlers(app)
if user_models:
with app.app_context():
_register_user_models(user_models, admin)
elif reflect_all:
with app.app_context():
_reflect_all(exclude_tables, admin)
return app
def activate_admin_classes():
prepare_relationships()
admin = Admin(app)
with app.app_context():
for cls in (cls for cls in current_app.classes_by_name.values()
if cls._use_admin == True):
admin.add_view(ModelView(cls, db.session))
def build_app(app):
app.register_blueprint(auth_bundle)
app.register_blueprint(home_bundle)
app.register_blueprint(api_bundle)
app.register_blueprint(profile_bundle)
app.register_blueprint(content_bundle)
app.register_blueprint(search_bundle)
# Config to Flask from objects
# app.config.from_object('fedora_college.core.ProductionConfig')
app.config.from_object('fedora_college.core.config.DevelopmentConfig')
db.init_app(app)
# FAS OpenID Instance
with app.app_context():
whooshalchemy.whoosh_index(app, Content)
whooshalchemy.whoosh_index(app, Media)
DebugToolbarExtension(app)
admin = Admin(app, 'Auth', index_view=FedoraAdminIndexView())
admin.add_view(FedoraModelView(UserProfile, db.session))
admin.add_view(FedoraModelView(Content, db.session))
admin.add_view(FedoraModelView(Media, db.session))
admin.add_view(FedoraModelView(Tags, db.session))
admin.add_view(
FedoraFileView(current_app.config['STATIC_FOLDER'],
name='Static Files'))
current_app.config['fas'] = FAS(app)
def create_app(name=__name__, config={},
static_folder='static', template_folder='templates'):
app = Flask(name, static_folder=static_folder,
template_folder=template_folder)
app.secret_key = os.environ.get('SECRET', 'secret')
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ['DB_URI']
app.config['DEBUG'] = bool(os.environ.get('DEBUG', False))
app.config.update(config)
from finance.models import db
db.init_app(app)
from finance.main import main_module
app.register_blueprint(main_module, url_prefix='')
admin = Admin(app, name='finance', template_mode='bootstrap3')
from finance.models import (
Account, Asset, AssetValue, Portfolio, Record, Transaction, User)
classes = [Account, Asset, AssetValue, Portfolio, Record, Transaction,
User]
for cls in classes:
admin.add_view(ModelView(cls, db.session,
endpoint=cls.__name__))
login_manager = LoginManager(app)
login_manager.login_view = 'user.login'
from finance.utils import date_range
app.jinja_env.filters['date_range'] = date_range
return app
def create_app(config='config.ProductionDevelopmentConfig'):
app = Flask(__name__)
app.config.from_object(config)
db.init_app(app)
mixer.init_app(app)
app.before_request(setup_authomatic(app))
app.before_request(load_user)
app.add_url_rule('/', 'index', index)
app.register_blueprint(auth_bp, url_prefix='/auth')
app.register_blueprint(issues_bp, url_prefix='/issues')
app.register_blueprint(comments_bp, url_prefix='/comments')
app.register_blueprint(organizations_bp, url_prefix='/organizations')
admin = Admin(app)
# add admin views.
admin.add_view(AdminView(User, db.session))
admin.add_view(AdminView(Issue, db.session))
admin.add_view(AdminView(Comment, db.session))
admin.add_view(AdminView(Organization, db.session))
admin.add_view(AdminView(Vote, db.session))
return app
def configure_extensions(app):
# flask-sqlalchemy
db.init_app(app)
# flask-mail
mail.init_app(app)
# flask-cache
cache.init_app(app)
# flask-babel
babel = Babel(app)
@babel.localeselector
def get_locale():
# TODO, first check user config?
g.accept_languages = app.config.get('ACCEPT_LANGUAGES')
accept_languages = g.accept_languages.keys()
browser_default = request.accept_languages.best_match(accept_languages)
if 'language' in session:
language = session['language']
# current_app.logger.debug('lang from session: %s' % language)
if language not in accept_languages:
# clear it
# current_app.logger.debug('invalid %s, clearing' % language)
session['language'] = None
language = browser_default
else:
language = browser_default
# current_app.logger.debug('lang from browser: %s' % language)
session['language'] = language # save it to session
# and to user?
return language
# flask-login
login_manager.login_view = 'frontend.login'
login_manager.refresh_view = 'frontend.reauth'
@login_manager.user_loader
def load_user(id):
return User.query.get(id)
login_manager.setup_app(app)
# flask-openid
oid.init_app(app)
# csrf for wtforms
# from flask.ext.wtf import csrf
csrf.init_app(app)
# flask-restless
rest.init_app(app, flask_sqlalchemy_db=db)
restless_routes() # actually setup the routes
# flask-admin
admin = Admin(app, name='RootIO Backend', index_view=AdminHomeView())
admin_routes(admin) # add flask-admin classes
def init_admin(app):
admin_url = '/admin'
admin = Admin(index_view=AdminPanel(url=admin_url),
name=lazy_gettext(u"Lab Manager"),
url=admin_url,
endpoint=admin_url)
i18n_LMSmngmt = lazy_gettext(u'LT Management')
admin.add_view(
LTPanel(db.session,
category=i18n_LMSmngmt,
name=lazy_gettext(u"LT"),
endpoint='lt/lt'))
admin.add_view(
PermissionToLtPanel(db.session,
category=i18n_LMSmngmt,
name=lazy_gettext(u"LT Permissions"),
endpoint='lt/permissions'))
admin.add_view(
LtUsersPanel(db.session,
category=i18n_LMSmngmt,
name=lazy_gettext(u"LT Users"),
endpoint='lt/users'))
admin.add_view(
LabRequestsPanel(db.session,
category=i18n_LMSmngmt,
name=lazy_gettext(u"LT Requests"),
endpoint='lt/requests'))
i18n_ReLMSmngmt = lazy_gettext(u'ReLMS Management')
admin.add_view(
RLMSPanel(db.session,
category=i18n_ReLMSmngmt,
name=lazy_gettext(u"RLMS"),
endpoint='rlms/rlms'))
admin.add_view(
LaboratoryPanel(db.session,
category=i18n_ReLMSmngmt,
name=lazy_gettext(u"Registered labs"),
endpoint='rlms/labs'))
admin.add_view(
UsersPanel(db.session,
category=lazy_gettext(u'Users'),
name=lazy_gettext(u"Labmanager Users"),
endpoint='users/labmanager'))
if app.config.get('GOLAB'):
admin.add_view(
EmbedApplicationsPanel(db.session,
category="Go-Lab",
name="Embed Apps",
endpoint='golab/embed'))
admin.add_view(
GoLabUsersPanel(db.session,
category="Go-Lab",
name="Go-Lab users",
endpoint='golab/users'))
admin.add_view(
RedirectView('logout',
name=lazy_gettext(u"Log out"),
endpoint='admin/logout'))
admin.init_app(app)
def make_admin(app):
myadmin = Admin(app, index_view=MyAdminIndexView(),
base_template='my_master.html',)
#template_mode='bootstrap3')
myadmin.add_view(EuFormatView(models.EuFormat))
myadmin.add_view(EuTemplateView(models.EuTemplate))
myadmin.add_view(TranslationRequestView(models.TranslationRequest))
myadmin.add_view(UserView(models.User))
return myadmin
def activate_admin_classes():
"""Activate each registed Model in the admin if it was registered with
*use_admin=True*."""
_prepare_relationships()
admin = Admin(app)
with app.app_context():
for cls in (cls for cls in current_app.classes_by_name.values()
if cls.use_admin == True):
admin.add_view(ModelView(cls, db.session))
def init_admin(app):
admin = Admin(app, index_view=IndexView(name="Add Match"), name="genkstaADMIN")
admin.add_view(SeasonView())
admin.add_view(PlayerView())
admin.add_view(SeasonStatsView())
admin.add_view(MatchView())
admin.add_view(PlayerMatchStatsView())
admin.add_view(PlayerMatchRatingView())
admin.add_view(GoToIndex(name='go to "/"'))
def create_admin(app=None, db=None):
admin = Admin(app,
'logStream',
index_view=AdminIndexView(),
base_template='admin/my_master.html')
admin.add_view(AdminUserView(User, db.session))
admin.add_view(AdminPostView(Post, db.session))
admin.add_view(AdminCategoryView(Category, db.session))
admin.add_view(AdminTagView(Tag, db.session))
def configure_admin(app):
admin = Admin(app, index_view=HomeAdminView())
admin.add_view(UserAdmin(db.session, name="User", endpoint="user", category="Auth"))
admin.add_view(UserProfileAdmin(db.session, name="UserProfile", endpoint="profile", category="Auth"))
admin.add_view(AuthView(Section, db.session, name="Section", endpoint="section", category="BBS"))
admin.add_view(AuthView(Node, db.session, name="Node", endpoint="node", category="BBS"))
admin.add_view(AuthView(Topic, db.session, name="Topic", endpoint="topic", category="BBS"))
admin.add_view(AuthView(Reply, db.session, name="Reply", endpoint="reply", category="BBS"))
def create_app(config):
"""Creates flask application with configuration
"""
app = App(__name__)
# Configure application
app.config.setdefault('DATABASE', 'db.db')
if isinstance(config, collections.Mapping):
app.config.update(config)
else:
app.config.from_object(config)
# View registering
views.register_views(app)
# DB connection
app.db_engine = create_engine(app.config['DATABASE'])
m.Base.metadata.bind = app.db_engine
m.Session.configure(bind=app.db_engine)
# Image Store
app.store = HttpExposedFileSystemStore('images', 'images/')
app.wsgi_app = app.store.wsgi_middleware(app.wsgi_app)
@app.before_request
def store_before_request():
context.push_store_context(app.store)
@app.teardown_request
def store_teardown_request(exception=None):
context.pop_store_context()
# Auth
app.register_blueprint(auth_blueprint)
@app.before_request
def before_request():
g.user = get_login_user()
# Middlewares
SQLAlchemyMiddleware(m.Session, app)
# Admin
def get_session():
session = getattr(self, '_session', None)
if (session is None) or not session.is_active:
session = m.Session()
setattr(self, '_session', session)
return session
session = Proxy(get_session)
admin = Admin(app)
admin.add_view(ModelView(m.Issue, session, category='models'))
admin.add_view(ModelView(m.User, session, category='models'))
return app
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
