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