def create_app(abcd_url=None):
# Define the WSGI application object
app = Flask(__name__)
app.logger.info('Creating an application')
app.config['SECRET_KEY'] = os.getenv('SECRET_KEY', os.urandom(12).hex())
app.config['ABCD_URL'] = os.getenv('ABCD_URL',
'mongodb://localhost:27017/abcd')
# Initialize extensions/add-ons/plugins.
nav.init_app(app)
register_renderer(app, 'BootstrapRenderer', BootstrapRenderer)
register_renderer(app, 'DatabaseNav', DatabaseNav)
db.init_app(app)
# Setup redirects and register blueprints.
app.register_blueprint(index.bp)
app.register_blueprint(database.bp, url_prefix='/db')
app.register_blueprint(api.bp, url_prefix='/api')
@app.errorhandler(404)
def not_found(error):
return render_template('404.html'), 404
return app
def init():
from datetime import datetime
from flask import Flask
from flask_bootstrap import Bootstrap
from flask_nav import Nav, register_renderer
from pathlib import PurePosixPath
from .bootstrap import top_nav, CustomBootstrapRenderer
from .config import PORTAL_NON_ROOT, SECRET_KEY, DEBUG, LAB_NAME, MAX_UPLOAD_SIZE, YANDEX_METRIKA
from .views import view_bp
app = Flask(__name__)
app.config['DEBUG'] = DEBUG
app.config['SECRET_KEY'] = SECRET_KEY
app.config['BOOTSTRAP_SERVE_LOCAL'] = DEBUG
app.config['ERROR_404_HELP'] = False
app.config['MAX_CONTENT_LENGTH'] = MAX_UPLOAD_SIZE
app.jinja_env.globals.update(year=datetime.utcnow,
laboratory=LAB_NAME,
yandex=YANDEX_METRIKA)
register_renderer(app, 'myrenderer', CustomBootstrapRenderer)
nav = Nav(app)
nav.register_element('top_nav', top_nav)
Bootstrap(app)
app_url = PurePosixPath('/') / (PORTAL_NON_ROOT or '')
app.register_blueprint(
view_bp, url_prefix=app_url.as_posix() if PORTAL_NON_ROOT else None)
return app
def create_app(config_name='default'):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
bootstrap.init_app(app)
nav.init_app(app)
db.init_app(app)
markdown.init_app(app)
admin.init_app(app)
from .models import User, Role, Post
user_datastore = SQLAlchemyUserDatastore(db, User, Role)
security.init_app(app, user_datastore)
admin.register(User, admin_class=ModelAdmin, session=db.session)
admin.register(Role, admin_class=ModelAdmin, session=db.session)
admin.register(Post, admin_class=ModelAdmin, session=db.session)
from .main import main as main_bp
app.register_blueprint(main_bp)
from .navbar import main_nav, RightRenderer
register_renderer(app, 'right_rendered', RightRenderer)
return app
def create_app():
app = Flask(__name__)
app.config.from_envvar('CALAPHIO_CONFIG')
# Register Blueprints
app.register_blueprint(core)
# Register Jinja Filters
app.jinja_env.filters['sanitize_html'] = sanitize_html
# Extensions
db.init_app(app)
login_manager.init_app(app)
csrf.init_app(app)
bootstrap.init_app(app)
nav.init_app(app)
principal.init_app(app)
register_renderer(app, "renderer", BetterBootstrapRenderer)
# Method Rewriter
app.wsgi_app = MethodRewriteMiddleware(app.wsgi_app)
# Identity Loader
identity_loaded.connect(on_identity_loaded, app, False)
return app
def init_app():
from .config import (PORTAL_NON_ROOT, SECRET_KEY, DEBUG, LAB_NAME, RESIZE_URL, IMAGES_PATH, MAX_UPLOAD_SIZE,
YANDEX_METRIKA, VK_ENABLE, JOBS_ENABLE, CGRDB_ENABLE, VIEW_ENABLE)
from .logins import load_user
app = Flask(__name__)
app.config['DEBUG'] = DEBUG
app.config['SECRET_KEY'] = SECRET_KEY
app.config['ERROR_404_HELP'] = False
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = '.login'
login_manager.user_loader(load_user)
app_url = PurePosixPath('/') / (PORTAL_NON_ROOT or '')
if VIEW_ENABLE:
from flask_bootstrap import Bootstrap
from flask_misaka import Misaka
from flask_nav import Nav, register_renderer
from flask_resize import Resize
from misaka import HTML_ESCAPE
from .views import view_bp
from .views.bootstrap import top_nav, CustomBootstrapRenderer, CustomMisakaRenderer
app.config['BOOTSTRAP_SERVE_LOCAL'] = DEBUG
app.config['RESIZE_URL'] = RESIZE_URL
app.config['RESIZE_ROOT'] = IMAGES_PATH
app.config['MAX_CONTENT_LENGTH'] = MAX_UPLOAD_SIZE
app.jinja_env.globals.update(year=datetime.utcnow, laboratory=LAB_NAME, yandex=YANDEX_METRIKA)
Resize(app)
register_renderer(app, 'myrenderer', CustomBootstrapRenderer)
nav = Nav(app)
nav.register_element('top_nav', top_nav)
Bootstrap(app)
Misaka(app, renderer=CustomMisakaRenderer(flags=0 | HTML_ESCAPE), tables=True, autolink=True,
underline=True, math=True, strikethrough=True, superscript=True, footnotes=True)
app.register_blueprint(view_bp, url_prefix=app_url.as_posix() if PORTAL_NON_ROOT else None)
if JOBS_ENABLE:
from .API import load_jobs
app.register_blueprint(load_jobs(), url_prefix=(app_url / 'api' / 'jobs').as_posix())
if CGRDB_ENABLE:
from .API import load_cgrdb
app.register_blueprint(load_cgrdb(), url_prefix=(app_url / 'api' / 'db').as_posix())
if VK_ENABLE:
from .vk import vk_bp
app.register_blueprint(vk_bp, url_prefix=(app_url / 'api' / 'vk').as_posix())
return app
def create_app(configfile=None):
# We are using the "Application Factory"-pattern here, which is described
# in detail inside the Flask docs:
# http://flask.pocoo.org/docs/patterns/appfactories/
app = Flask(__name__)
# We use Flask-Appconfig here, but this is not a requirement
AppConfig(app, configfile)
# Install our Bootstrap extension
bootstrap.init_app(app)
# Install our Misaka (Markdown) extension
misaka.init_app(app)
debug.init_app(app)
# Our application uses blueprints as well; these go well with the
# application factory. We already imported the blueprint, now we just need
# to register it:
app.register_blueprint(frontend)
# # Because we're security-conscious developers, we also hard-code disabling
# # the CDN support (this might become a default in later versions):
# app.config['BOOTSTRAP_SERVE_LOCAL'] = False
# We initialize the navigation as well
nav.init_app(app)
register_renderer(app, 'inverse', InverseRenderer)
# REST V1
from app.blueprints.api_v1.views import api_v1_bp
app.register_blueprint(api_v1_bp, url_prefix='/api/v1')
return app
def initialise_nav(app):
register_renderer(app, 'just_li', JustLiRenderer)
nav.init_app(app)
def init():
from datetime import datetime
from os.path import join
from flask import Flask
from flask_bootstrap import Bootstrap
from flask_login import LoginManager
from flask_misaka import Misaka
from misaka import HTML_ESCAPE
from flask_nav import Nav, register_renderer
from flask_resize import Resize
from pony.orm import sql_debug
from .API import api_bp
from .views import view_bp
from .bootstrap import top_nav, CustomBootstrapRenderer, CustomMisakaRenderer
from .config import (PORTAL_NON_ROOT, SECRET_KEY, DEBUG, LAB_NAME, RESIZE_URL, UPLOAD_PATH, IMAGES_ROOT,
MAX_UPLOAD_SIZE, YANDEX_METRIKA, DB_PASS, DB_HOST, DB_USER, DB_NAME)
from .logins import load_user
from .models import db, data_db
if DEBUG:
sql_debug(True)
db.bind('sqlite', 'database.sqlite')
db.generate_mapping(create_tables=True)
for x in data_db.values():
x.bind('sqlite', 'database.sqlite')
x.generate_mapping(create_tables=True)
else:
db.bind('postgres', user=DB_USER, password=DB_PASS, host=DB_HOST, database=DB_NAME)
db.generate_mapping()
for x in data_db.values():
x.bind('postgres', user=DB_USER, password=DB_PASS, host=DB_HOST, database=DB_NAME)
x.generate_mapping()
app = Flask(__name__)
app.config['DEBUG'] = DEBUG
app.config['SECRET_KEY'] = SECRET_KEY
app.config['BOOTSTRAP_SERVE_LOCAL'] = DEBUG
app.config['ERROR_404_HELP'] = False
app.config['RESIZE_URL'] = RESIZE_URL
app.config['RESIZE_ROOT'] = IMAGES_ROOT
app.config['MAX_CONTENT_LENGTH'] = MAX_UPLOAD_SIZE
app.jinja_env.globals.update(year=datetime.utcnow, laboratory=LAB_NAME, yandex=YANDEX_METRIKA)
Resize(app)
register_renderer(app, 'myrenderer', CustomBootstrapRenderer)
nav = Nav(app)
nav.register_element('top_nav', top_nav)
Bootstrap(app)
Misaka(app, renderer=CustomMisakaRenderer(flags=0 | HTML_ESCAPE), tables=True,
underline=True, math=True, strikethrough=True, superscript=True, footnotes=True, smartypants=False)
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = '.login'
login_manager.user_loader(load_user)
app.register_blueprint(api_bp, url_prefix=join('/', PORTAL_NON_ROOT, 'api'))
app.register_blueprint(view_bp, url_prefix=join('/', PORTAL_NON_ROOT) if PORTAL_NON_ROOT else None)
return app
def flaskrun(options):
# use environemnt variables for config
app.config.update(os.environ)
app.config["SECRET_KEY"] = os.urandom(512)
app.config["WTF_CSRF_ENABLED"] = True
app.config["WTF_CSRF_SECRET_KEY"] = os.urandom(512)
app.config["SERVER_OPTIONS"] = options
app.config[
'SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://ptu:ptu@localhost:3306/ptu'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
import routes
from blueprints.session import session
app.register_blueprint(session)
from blueprints.system import system
app.register_blueprint(system)
from blueprints.map import map_blueprint
app.register_blueprint(map_blueprint)
from blueprints.data import data
app.register_blueprint(data)
from blueprints.rtlsdr import rtlsdr
app.register_blueprint(rtlsdr)
from blueprints.gpsd import gpsd
app.register_blueprint(gpsd)
from blueprints.kismet import kismet
app.register_blueprint(kismet)
app.jinja_env.globals['bootstrap_is_hidden_field'] = is_hidden_field_filter
if not options.debug:
if options.verbosity <= 1: app.logger.setLevel(logging.ERROR)
elif options.verbosity <= 2: app.logger.setLevel(logging.WARNING)
elif options.verbosity <= 3: app.logger.setLevel(logging.INFO)
else:
app.logger.setLevel(logging.DEBUG)
app.jinja_env.cache = None
app.config['ASSETS_DEBUG'] = "merge"
app.config['DEBUG'] = True
app.config['ASSETS_CACHE'] = "/tmp"
if options.trace:
app.config['PROFILE'] = True
app.wsgi_app = ProfilerMiddleware(app.wsgi_app, restrictions=[30])
assets.init_app(app)
db.init_app(app)
app.config['SESSION_TYPE'] = 'sqlalchemy'
app.config['SESSION_SQLALCHEMY'] = db
sess.init_app(app)
login_manager.init_app(app)
login_manager.login_view = 'session.login'
csrf.init_app(app)
from navigation import nav
nav.init_app(app)
from lib.bootstraprenderer import BootstrapRenderer
register_renderer(app, 'bootstrap', BootstrapRenderer)
socketio.init_app(app)
compress.init_app(app)
with app.app_context():
# setup database models
db.create_all()
if options.ssl == True:
from lib.ssl import getSSLContext
#app.run(host=options.host,port=int(options.port),ssl_context=getSSLContext(app),debug=options.debug,threaded=True)
CERT_FILE, KEY_FILE = getSSLContext(app)
socketio.run(app,
host=options.host,
port=int(options.port),
certfile=CERT_FILE,
keyfile=KEY_FILE,
debug=options.debug)
else:
#app.run(app,host=options.host,port=int(options.port),debug=options.debug,threaded=True)
socketio.run(app,
host=options.host,
port=int(options.port),
debug=options.debug)
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
app = Flask(__name__)
app.config.from_object('nashi.default_settings')
app.config.from_envvar('NASHI_SETTINGS', silent=True)
mail = Mail(app)
Bootstrap(app)
import nashi.views
nav = Nav()
nav.init_app(app)
register_renderer(app, 'navrender', ownRenderer)
import nashi.navigation
user_datastore = SQLAlchemySessionUserDatastore(db_session, User, Role)
security = Security(app, user_datastore)
celery = make_celery(app)
import nashi.tasks
@app.teardown_appcontext
def shutdown_session(exception=None):
db_session.remove()
from flask import Flask, render_template
from flask_bootstrap import Bootstrap
from flask_nav import register_renderer
from flask_nav.elements import Navbar, View, Subgroup
from flask_heroku import Heroku
from .nav import nav
from .nav import CustomRenderer
srp = Flask(__name__)
Bootstrap(srp)
Heroku(srp)
nav.init_app(srp)
register_renderer(srp, 'custom', CustomRenderer)
nav.register_element(
'navbar',
Navbar(
View('Home', '.index'),
Subgroup(
'Character',
View('Character Creation', '.startingCharacterCreation'),
View('Stats', '.stats'),
View('Advantages and Disadvantages',
'.advantagesAndDisadvantages'),
View('Character Growth', '.characterGrowth'),
),
Subgroup(
'Combat',
View('Combat Flow', '.combat'),
View('Weapons', '.weapons'),
View('Armor', '.armor'),
loginuser = User.query.filter_by(id=user_id).first()
if not loginuser:
username = user['username']
discriminator = user['discriminator']
loginuser = User(user['id'], user['username'], user['discriminator'])
db.session.add(loginuser)
db.session.commit()
login_user(loginuser, True)
session['username'] = user['username']
session['oauth2_token'] = token
return redirect(url_for('index'))
@app.route('/discord/logout')
def discord_logout():
logout_user()
return redirect(url_for('index'))
register_renderer(app, 'navbar', MyNavRenderer)
nav.init_app(app)
os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1'
db.create_all()
if __name__ == '__main__':
app.run(debug=True)
import os
from flask import Flask
from flask_bootstrap import Bootstrap
from flask_nav import Nav, register_renderer
from App.Navbar.NavbarRenderer import AppRenderer
app = Flask(__name__, template_folder=os.path.normpath("../templates"), static_folder=os.path.normpath("../static"))
nav = Nav()
boot = Bootstrap()
boot.init_app(app)
nav.init_app(app)
register_renderer(app, 'app_renderer', AppRenderer)
app.config.from_object(os.environ['APP_SETTINGS']) from flask.ext.sqlalchemy import SQLAlchemy from flask.ext.bcrypt import Bcrypt db = SQLAlchemy(app) bcrypt = Bcrypt(app) # Import blueprints from revue.api import api from revue.public.views import public_site from revue.internal.views import internal_site from revue.admin.views import admin_site # Register blueprints app.register_blueprint(api, url_prefix='/api') app.register_blueprint(internal_site, url_prefix='/intern') app.register_blueprint(admin_site, url_prefix='/admin') app.register_blueprint(public_site) # Setup logging # TODO: create sane defaults for development import logging logging.basicConfig(level=logging.DEBUG) from revue.utilities.ui.bootstrap import CustomBootstrapRenderer register_renderer(app, 'custom_bootstrap_nav', CustomBootstrapRenderer) nav.init_app(app)
def init_app(self, app):
register_renderer(app, None, BootstrapRenderer)
super(MyNav, self).init_app(app)
from logging.handlers import SMTPHandler
from logging import Formatter
nav = Nav()
items = [View(*x) for x in MENU]
right_items = [UserGreeting(), LogInLogOut()]
nav.register_element(
'top',
ExtendedNavbar(title=items[0], items=items[1:], right_items=right_items))
csrf = CSRFProtect()
app = Flask(__name__)
app.config.from_object('config')
Bootstrap(app)
nav.init_app(app)
register_renderer(app, 'eprihlaska_nav_renderer', ePrihlaskaNavRenderer)
csrf.init_app(app)
babel = Babel(app)
app.config['BABEL_DEFAULT_LOCALE'] = 'sk_SK'
locale.setlocale(locale.LC_ALL, 'sk_SK.utf8')
configure_uploads(app, receipts)
configure_uploads(app, uploaded_files)
mail_handler = SMTPHandler(mailhost=app.config['ERROR_EMAIL_SERVER'],
fromaddr=app.config['ERROR_EMAIL_FROM'],
toaddrs=app.config['ADMINS'],
subject=app.config['ERROR_EMAIL_HEADER'])
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(
def create_app(config_file=None):
app = Flask('app')
AppConfig(app, config_file)
SSLify(app)
stream = logging.StreamHandler()
stream.setFormatter(logging.Formatter(
'%(name)s %(levelname)s %(asctime)s "%(message)s"'
))
admin_logger = logging.getLogger('app.admin')
admin_logger.setLevel(logging.INFO)
admin_logger.addHandler(stream)
db.app = app
db.init_app(app)
bootstrap.app = app
bootstrap.init_app(app)
nav.app = app
nav.register_element('top', get_navbar)
register_renderer(app, 'twoside', TwoSideRenderer)
nav.init_app(app)
login_manager.app = app
login_manager.init_app(app)
mail.app = app
mail.init_app(app)
cache.app = app
cache.init_app(app)
oauth.app = app
oauth.init_app(app)
bind_sqlalchemy(oauth, db.session,
user=User,
client=oauth2.Client,
token=oauth2.Token,
grant=oauth2.Grant,
current_user=lambda: current_user)
if not app.debug:
sentry.app = app
sentry.init_app(app)
admin.app = app
admin.init_app(app)
admin.add_view(AdAdminView(Ad, db.session))
admin.add_view(LinkAdminView(Link, db.session))
admin.add_view(trial.TrialEmailAdminView(trial.TrialEmail, db.session))
#celery.app = app
#celery.init_app(app)
user_manager.init_app(
app,
db_adapter=SQLAlchemyAdapter(db, User, UserInvitationClass=UserInvitation),
login_manager=login_manager
)
gravatar.app = app
gravatar.init_app(app)
api_manager.app = app
api_manager.init_app(app)
app.register_blueprint(trial.bp, url_prefix='/trial')
app.register_blueprint(oauth2.view.bp, url_prefix='/oauth')
app.register_blueprint(social.bp, url_prefix='/social')
app.register_blueprint(dashboard.bp, url_prefix='/dashboard')
app.register_blueprint(share.bp, url_prefix='/share')
app.register_blueprint(web.bp)
for jinja_filter in FILTERS:
app.jinja_env.filters[jinja_filter] = FILTERS[jinja_filter]
for jinja_test in TESTS:
app.jinja_env.tests[jinja_test] = TESTS[jinja_test]
return app
def create_app():
"""Initialize the core application."""
app = Flask(__name__,
instance_relative_config=False,
template_folder='web/templates',
static_folder='web/static',
static_url_path="/static")
if config.has_option('security', 'webserver_password'):
app.config['SECRET_KEY'] = config.get('security', 'webserver_password')
if config.has_option('database', 'connection_string'):
from sqlalchemy_utils import create_database, database_exists
connection_string = config.get('database', 'connection_string')
connect_args = {"options": "-c timezone=utc"}
app.config['SQLALCHEMY_DATABASE_URI'] = connection_string
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['SQLALCHEMY_ENGINE_OPTIONS'] = {
"connect_args": connect_args
}
app.config['DATABASE_CREATED'] = False
if not database_exists(connection_string):
create_database(connection_string)
app.config['DATABASE_CREATED'] = True
csrf.init_app(app)
# app.config.from_object('config.Config')
app.register_error_handler(404, page_not_found)
# Initialize Plugins
db.init_app(app)
migrate.init_app(app,
db,
directory=os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'migrations'))
manager.__init__(app)
manager.add_command('db', MigrateCommand)
login_manager.login_view = 'auth.login'
login_manager.init_app(app)
nav.init_app(app)
nav.register_element('top', top_nav)
register_renderer(app, 'bootstrap', Bootstrap4Renderer)
register_renderer(app, 'neon-lights', NeonLightsRenderer)
themer.init_app(app)
# CSRFProtect(app)
Bootstrap(app)
@login_manager.user_loader
def load_user(user_id):
from .model import User
# since the user_id is just the primary key of our user table, use it in the query for the user
return User.query.get(int(user_id))
@app.context_processor
def get_navigation():
if user_logged_out:
navigation = {
'.index': 'Home',
'.signup': 'Sign Up',
'.login': '******'
}
else:
if current_user.is_admin:
navigation = {
'.dashboard': 'Dashboard',
'.admin': 'Admin',
'.profile': 'Profile',
'.logout': 'Logout'
}
else:
navigation = {
'.dashboard': 'Dashboard',
'.profile': 'Profile',
'.logout': 'Logout'
}
return navigation
@themer.current_theme_loader
def get_current_theme():
if hasattr(current_user, 'theme') and current_user.theme:
return current_user.theme
elif request and request.cookies and request.cookies.get(
'chronos-preference-theme'):
return request.cookies.get('chronos-preference-theme')
else:
return 'moon-base-alpha'
@app.context_processor
def context_processor():
def url_for_static(filename):
# root = os.path.join(os.curdir, 'chronos\web\static')
return urllib.parse.urljoin('/chronos/web/static/', filename)
# return os.path.abspath(os.path.join(os.path.join(root, 'chronos\web\static'), filename))
return dict(url_for_static=url_for_static)
app.add_url_rule('/static/favicon/<path:filename>/',
endpoint='favicon',
view_func=app.send_static_file)
app.add_url_rule('/static/js/<path:filename>/',
endpoint='js',
view_func=app.send_static_file)
with app.app_context():
# Include our Routes
# blueprint for non-auth routes in our app
from chronos.web.authentication.auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint,
template_folder='templates',
static_folder='static')
auth_blueprint.template_folder = 'templates'
auth_blueprint.static_folder = 'static'
# blueprint for regular user parts of app
from chronos.web.user.user import user as user_blueprint
app.register_blueprint(user_blueprint,
template_folder='templates',
static_folder='static')
user_blueprint.template_folder = 'templates'
user_blueprint.static_folder = 'static'
# blueprint for admin user parts of app
from chronos.web.admin.admin import admin as admin_blueprint
app.register_blueprint(admin_blueprint,
template_folder='templates',
static_folder='static')
admin_blueprint.template_folder = 'templates'
admin_blueprint.static_folder = 'static'
from chronos.web import crud
crud.UserView.register(admin_blueprint, db.session)
crud.ExchangeView.register(admin_blueprint, db.session)
crud.ApiKeyView.register(user_blueprint, db.session)
crud.register(app, db.session)
return app
def register_nav_renderers(server):
register_renderer(server, 'bootstrap', CustomBootstrapRenderer)
def create_app(test_config=None):
"""
Params::
test_config: (mapping) Used to configure the app.
Returns::
App: Created Flask App
"""
# Create and configure the app
app = Flask(__name__)
# Enable white-space trimming (USELESS WITH MINIFY)
# app.jinja_env.trim_blocks = True
# app.jinja_env.lstrip_blocks = True
if test_config is None:
# Load the instance config, if it exists, when not testing
app.config.from_pyfile('config.py')
else:
# Laod the test config if passed in
app.config.from_mapping(test_config)
# Admin
admin.init_app(app)
# Obscure
obscure.init_app(app)
# For CSRF Protection
csrf = CSRFProtect(app)
# Minify HTML, JS, CSS
mini = minify(app, caching_limit=0)
# For Header Security
talisman = Talisman(
app,
content_security_policy=csp,
content_security_policy_nonce_in=['script-src'],
)
# Bootstrap Wrapper
bootstrap = Bootstrap(app)
app.extensions['bootstrap']['cdns']['jquery'] = WebCDN(
'//cdnjs.cloudflare.com/ajax/libs/jquery/2.1.1/')
# Initialize Database from database.py where models are created
db.init_app(app)
# Migration
migrate = Migrate(app, db, compare_type=True)
# Initialize flask-nav
nav.init_app(app)
register_renderer(app, 'custom', CustomRenderer)
# Set-up login_manager
auth.login_manager.init_app(app)
auth.login_manager.login_view = 'auth/login'
# Ensure the instance folder exists
try:
os.makedirs(app.instance_path)
print("Creating the instance path")
except OSError:
print("Instance path is already created. Using the existing directory")
# Register Blueprints
app.register_blueprint(auth.bp)
app.register_blueprint(posts.bp)
app.register_blueprint(user.bp)
# TODO: Turn this to a infinite scroll using API calls with JSON returns
@app.route('/', methods=['GET', 'POST'])
def index():
if not current_user.is_authenticated and current_user.is_anonymous:
return render_template('welcome.html')
post_list = posts.Post.query.order_by(posts.Post.created.desc()).all()
return render_template('base.html', posts=post_list)
@app.route('/follow_feed', methods=['GET', 'POST'])
@login_required
def follow_feed():
followed_posts = current_user.followed_posts()
return render_template('base.html', posts=followed_posts)
@app.errorhandler(404)
def page_not_found(e):
return render_template('404.html'), 404
app.add_url_rule('/index', '/')
return app
from app.db import DB
from datetime import datetime
from flask_nav import register_renderer
from app.nav import nav, DefaultNavRenderer, initNav
app = Flask(__name__)
app.config.from_object('config')
# Init login manager
login_manager = flask_login.LoginManager()
login_manager.init_app(app)
# Init nav on app object
nav.init_app(app)
register_renderer(app, 'defaultNav', DefaultNavRenderer)
# Setup database
@app.before_request
def before():
g.db = DB()
g.user = flask_login.current_user
initNav()
@app.teardown_request
def after(exception):
if hasattr(g, 'db'):
g.db.close(exception)
def create_app():
fapp = Flask(__name__)
fapp.config['SECRET_KEY'] = SECRET_KEY
fapp.config['BOOTSTRAP_SERVE_LOCAL'] = BOOTSTRAP_SERVE_LOCAL
lm = LoginManager()
lm.init_app(fapp)
lm.login_view = 'login'
nav = Nav()
nav.init_app(fapp)
Bootstrap(fapp)
register_renderer(fapp, 'myrenderer', Customrenderer)
nav.register_element('top_nav', top_nav)
return fapp, lm, nav
