def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. appname.settings.ProdConfig
"""
app = Flask(__name__, static_url_path='/static')
app.config.from_object(object_name)
db.init_app(app)
login_manager.init_app(app)
mail.init_app(app)
# Import and register the different assets bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# Loading the Blueprint in controllers defined by main.py - Handles routing
app.register_blueprint(main_blueprint)
app.register_blueprint(user_blueprint)
return app
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. resrv.settings.ProdConfig
"""
app = Flask(__name__)
app.config.from_object(object_name)
# initialize SQLAlchemy
db.init_app(app)
login_manager.init_app(app)
humanize.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
app.register_blueprint(main)
return app
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. appname.settings.ProdConfig
"""
app = Flask(__name__)
app.config.from_object(object_name)
# initialize the cache
cache.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
# FIXME: init arango
# db.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
app.register_blueprint(main)
app.register_blueprint(authors)
return app
def register_extensions(app):
# initialize SQLAlchemy
db.init_app(app)
# initialize the cache
cache.init_app(app)
# initialize security
ds = SQLAlchemyUserDatastore(db, User, Role)
security.init_app(app, datastore=ds,
register_form=forms.ExtendedRegisterForm)
# initialize bootstrap resource
bootstrap.init_app(app)
# initialize the debug tool bar
#debug_toolbar.init_app(app)
# Initialize social
social_ds = SQLAlchemyConnectionDatastore(db, Connection)
social.init_app(app, social_ds)
#Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().iteritems():
assets_env.register(name, bundle)
return None
def create_app(object_name, env="dev"):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. mobsec.settings.ProdConfig
env: The name of the current environment, e.g. prod or dev
"""
app = Flask(__name__)
app.config.from_object(object_name)
app.config['ENV'] = env
# initialize the cache
cache.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
app.register_blueprint(main)
return app
def create_app(object_name, env="prod"):
"""
A flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Inputs: ::\n
object_name: the python path of the config object,
e.g. appname.settings.ProdConfig
env: The name of the current environment, e.g. prod or dev
"""
app = Flask(__name__)
app.config.from_object(object_name)
app.config['ENV'] = env
# Init the cache
cache.init_app(app)
# Init debug toolbar
debug_toolbar.init_app(app)
# Init Mongo engine
# mongoengine.connect(config.MONGODB_FRONTEND_DB_NAME, host=config.MONGODB_HOST, port=config.MONGODB_PORT)
app.config['MONGODB_DB'] = config.MONGODB_FRONTEND_DB_NAME
app.config['MONGODB_HOST'] = config.MONGODB_HOST
app.config['MONGODB_PORT'] = config.MONGODB_PORT
db.init_app(app)
# Init login_manager
login_manager.init_app(app)
login_manager.login_view = "main.login"
login_manager.refresh_view = "main.login"
# Init current to track current project/experiment
current.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().iteritems():
assets_env.register(name, bundle)
# register all the blueprints
from controllers import (main, error, dashboard, new_experiment,
new_project, account_settings, project,
experiment, targets, setup)
app.register_blueprint(main)
app.register_blueprint(error, url_prefix="/error")
app.register_blueprint(dashboard, url_prefix="/dashboard")
app.register_blueprint(new_experiment, url_prefix="/new_experiment")
app.register_blueprint(new_project, url_prefix="/new_project")
app.register_blueprint(account_settings, url_prefix="/account_settings")
app.register_blueprint(project, url_prefix="/project")
app.register_blueprint(experiment, url_prefix="/experiment")
app.register_blueprint(targets, url_prefix="/targets")
app.register_blueprint(setup, url_prefix="/setup")
return app
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. mothership.settings.ProdConfig
env: The name of the current environment, e.g. prod or dev
"""
app = Flask(__name__)
@app.before_first_request
def _run_on_start():
init_db()
csrf = CsrfProtect(app)
@app.template_filter('datetime')
def datetimeformat(value, format='%d/%m/%y %H:%M %p'):
return datetime.datetime.utcfromtimestamp(value).strftime(format)
app.config.from_object(object_name)
# initialize the cache
cache.init_app(app)
# initialize the debug tool bar
# debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
login_manager.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
app.register_blueprint(main)
app.register_blueprint(campaigns)
app.register_blueprint(graphs)
app.register_blueprint(fuzzers)
csrf.exempt(fuzzers)
try:
os.mkdir(app.config['DATA_DIRECTORY'])
except FileExistsError:
pass
return app
def create_app(config='', **config_kwargs):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
config: the path of config file
config_kwargs: overrides
Default config read from flocka/config_default.py
See FiftyFlask docs
"""
app = Flask(__name__)
config = config if os.path.isfile(config) else None
app.configure(config, **config_kwargs)
# Cache
cache.init_app(app)
# Logging
app.logger.addHandler(logging.StreamHandler(sys.stderr))
# Debug toolbar
debug_toolbar.init_app(app)
# SQLAlchemy
db.init_app(app)
# Flask Login
login_manager.init_app(app)
# FiftyTables
FiftyTables(app)
# Alembic
migrate.init_app(app, db)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().iteritems():
assets_env.register(name, bundle)
# Register our blueprints
from controllers import main, branches
app.register_blueprint(main.main_bp)
app.register_blueprint(branches.branched_bp)
# Jinja extensions
app.jinja_env.add_extension('jinja2.ext.do')
app.jinja_env.add_extension('jinja2.ext.loopcontrols')
return app
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. pele.settings.ProductionConfig
"""
app = Flask(__name__)
app.config.from_object(object_name)
app.config.from_pyfile('../settings.cfg') # override
# register converters
app.url_map.converters['list'] = ListConverter
# set debug logging level
if app.config.get('DEBUG', False):
app.logger.setLevel(logging.DEBUG)
cors.init_app(app)
app.wsgi_app = ReverseProxied(app.wsgi_app, app.config)
app.es_client = get_es_client(app.config)
app.es_util = QueryES(app.es_client, logger=app.logger)
# init extensions
cache.init_app(app)
debug_toolbar.init_app(app)
bcrypt.init_app(app)
db.init_app(app)
login_manager.init_app(app)
limiter.init_app(app)
mail.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in list(assets_loader.load_bundles().items()):
assets_env.register(name, bundle)
# register our blueprints
from .controllers.main import main
app.register_blueprint(main)
from .controllers.api_v01 import services as api_v01
app.register_blueprint(api_v01)
app.register_blueprint(apidoc.apidoc)
return app
def create_app(environment_name='dev'):
app = Flask(__name__)
config = configurations[environment_name]
app.config.from_object(config)
db.init_app(app)
csrf.init_app(app)
# need render_as_batch to correctly generate migrations for sqlite
migrate.init_app(app, db, render_as_batch=True)
login_manager.init_app(app)
mail.init_app(app)
checkout.init_app(app)
assets_env.init_app(app)
rq2.init_app(app)
debug_toolbar.init_app(app)
cache.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
if app.config["SENTRY_DSN"]: # pragma: no cover
sentry_sdk.init(dsn=app.config["SENTRY_DSN"],
integrations=[
FlaskIntegration(),
SqlalchemyIntegration(),
RqIntegration()
])
@app.errorhandler(401)
def unauthorized_error(error):
return render_template('errors/401.html'), 401 # pragma: no cover
@app.errorhandler(404)
def not_found_error(error):
return render_template('errors/404.html'), 404
@app.errorhandler(500)
def internal_error(error):
return render_template('errors/500.html'), 500 # pragma: no cover
app.register_blueprint(product_bp, url_prefix='/product')
app.register_blueprint(store_bp)
app.register_blueprint(user_bp)
app.register_blueprint(checkout_bp)
app.register_blueprint(landing_bp)
# Admin tools
app.register_blueprint(rq_blueprint, url_prefix="/rq")
csrf.exempt(rq_blueprint)
return app
def create_app(environment_name='dev'):
app = Flask(__name__)
app.config.from_object(configurations[environment_name])
# init extensions
db.init_app(app)
csrf.init_app(app)
login_manager.init_app(app)
migrate.init_app(app, db, render_as_batch=True)
mail.init_app(app)
checkout.init_app(app)
rq2.init_app(app)
debug_toolbar.init_app(app)
cache.init_app(app)
# assets bundling
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register blueprints
app.register_blueprint(products, url_prefix="/product")
app.register_blueprint(user_bp)
app.register_blueprint(store_bp)
app.register_blueprint(checkout_bp)
app.register_blueprint(landing_bp)
app.register_blueprint(rq_blueprint, url_prefix="/rq")
# errors monitoring
if app.config.get("SENTRY_DSN"):
sentry_sdk.init(
dsn=app.config["SENTRY_DSN"],
integrations=[FlaskIntegration(), SqlalchemyIntegration()]
)
# errors handling
@app.errorhandler(401)
def unauthorized_error(error):
return render_template('errors/401.html'), 401
@app.errorhandler(404)
def not_found_error(error):
return render_template('errors/404.html'), 404
@app.errorhandler(500)
def internal_error(error):
return render_template('errors/500.html'), 500
return app
def create_app(object_name, env="prod"):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. ivy_3dprint_site.settings.ProdConfig
env: The name of the current environment, e.g. prod or dev
"""
app = Flask(__name__)
app.config.from_object(object_name)
app.config['ENV'] = env
#init the cache
cache.init_app(app)
#init SQLAlchemy
db.init_app(app)
#int Flask-admin
admin = Admin(app)
from controllers.admin import UserView, ProductView
from models import User, Tag, Lang, Photo, Product, \
File, Sample, Contact, About
from forms import CKTextAdmin
admin.add_view(UserView(User))
admin.add_view(ModelView(Tag))
admin.add_view(ModelView(Lang))
admin.add_view(ModelView(Photo))
admin.add_view(ModelView(File))
admin.add_view(ProductView(Product))
admin.add_view(CKTextAdmin(Sample))
admin.add_view(CKTextAdmin(Contact))
admin.add_view(CKTextAdmin(About))
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().iteritems():
assets_env.register(name, bundle)
# register our blueprints
from controllers.main import main
app.register_blueprint(main)
return app
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. appname.settings.ProdConfig
"""
app = Flask(__name__)
@app.route('/uploads/<filename>')
def uploaded_file(filename):
return send_from_directory('/home/ahmad/workspace/python/Flask-CRUD/uploads/', filename)
Bootstrap(app)
app.config.from_object(object_name)
# initialize the cache
cache.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
db.app = app
login_manager.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
with app.app_context():
assets_env.load_path = [
os.path.join(os.path.join(os.path.dirname(__file__), os.pardir), 'node_modules'),
os.path.join(os.path.dirname(__file__), 'static'),
]
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
app.register_blueprint(main)
app.register_blueprint(categories)
app.register_blueprint(products)
app.register_blueprint(catalogs)
return app
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config_name)
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
login_manager.init_app(app)
app.register_blueprint(main)
app.register_blueprint(admin, url_prefix='/admin')
return app
def create_app(environment_name='dev'):
app = Flask(__name__)
app.config.from_object(configurations[environment_name])
db.init_app(app)
csrf.init_app(app)
login_manager.init_app(app)
migrate.init_app(app, db, render_as_batch=True)
# mail.init_app(app)
checkout.init_app(app)
assets_env.init_app(app)
rq2.init_app(app)
debug_toolbar.init_app(app)
cache.init_app(app)
if app.config.get('SENTRY_DSN'):
sentry_sdk.init(
dsn=app.config['SENTRY_DSN'],
integrations=[FlaskIntegration(),
SqlalchemyIntegration()],
send_default_pii=True,
traces_sample_rate=1.0) # pragma: no cover
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
app.register_blueprint(products, url_prefix='/product')
app.register_blueprint(user_bp)
app.register_blueprint(store_bp, url_prefix='/store')
app.register_blueprint(checkout_bp)
app.register_blueprint(landing_bp)
app.register_blueprint(rq_blueprint, url_prefix='/rq')
csrf.exempt(rq_blueprint)
@app.errorhandler(401)
def unauthorized_error(error):
return render_template('errors/401.html'), 401 # pragma: no cover
@app.errorhandler(404)
def not_found_error(error):
return render_template('errors/404.html'), 404
@app.errorhandler(500)
def internal_error(error):
return render_template('errors/500.html'), 500 # pragma: no cover
return app
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. {{cookiecutter.app_name}}.settings.ProdConfig
env: The name of the current environment, e.g. prod or dev
"""
app = Flask(__name__)
app.config.from_object(object_name)
if cache:
# initialize the cache
cache.init_app(app)
if debug_toolbar:
# initialize the debug tool bar
debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
login_manager.init_app(app)
# Import and register the different asset bundles
if assets_env:
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
main_controller.before_request(before_app_request)
app.register_blueprint(main_controller)
admin_controller.before_request(before_app_request)
app.register_blueprint(admin_controller)
file_controller.before_request(before_app_request)
app.register_blueprint(file_controller)
return app
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. {{cookiecutter.repo_name}}.settings.ProdConfig
env: The name of the current environment, e.g. prod or dev
"""
app = Flask(__name__)
app.config.from_object(object_name)
#initialize CORS
CORS(app, resources={r"/*":{"origins":"*"}})
# initialize the cache
cache.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
#initialize migration
migrate.init_app(app, db)
#initialize socket
# socketio.init_app(app)
login_manager.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
app.register_blueprint(api)
return app
def create_app(object_name, env="development"):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
:argument string object_name: Object name
:argument string env: Environment
"""
app = Flask(__name__)
app.config.from_object(object_name)
app.config['ENV'] = env
configure_logging(app)
# init the cache
cache.init_app(app)
# init debug toolbar
debug_toolbar.init_app(app)
# init notifications object
notifications = Notifications()
notifications.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register index blueprint
from app.controllers.index import index
app.register_blueprint(index)
# register api blueprints
api_prefix = "/{0}".format(app.config['API_VERSION'])
from app.controllers.errors import errors
app.register_blueprint(errors, url_prefix=api_prefix)
from app.controllers.status import status
app.register_blueprint(status, url_prefix=api_prefix)
return app
def create_app(object_name, env="prod"):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. fv_prov_es.settings.ProdConfig
env: The name of the current environment, e.g. prod or dev
"""
app = Flask(__name__)
app.wsgi_app = ReverseProxied(app.wsgi_app)
app.config.from_object(object_name)
app.config['ENV'] = env
#init extensions
cache.init_app(app)
debug_toolbar.init_app(app)
db.init_app(app)
login_manager.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().iteritems():
assets_env.register(name, bundle)
# register our blueprints
from controllers.main import main
app.register_blueprint(main)
from controllers.services_v01 import services as services_v01
app.register_blueprint(services_v01)
from controllers.services_v02 import services as services_v02
app.register_blueprint(services_v02)
app.register_blueprint(apidoc.apidoc)
return app
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. trading.settings.ProdConfig
"""
app = Flask(__name__)
app.config.from_object(object_name)
# initialize the cache
cache.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
login_manager.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
app.register_blueprint(main)
app.register_blueprint(portfolio, url_prefix="/api/v1")
app.register_blueprint(search, url_prefix="/api/v1")
app.register_blueprint(quotes, url_prefix="/api/v1")
api.init_app(app)
@app.errorhandler(404)
def page_not_found(e):
return app.send_static_file('index.html')
return app
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. flaskheartbeat.settings.ProdConfig
env: The name of the current environment, e.g. prod or dev
"""
app = Flask(__name__)
app.config.from_object(object_name)
# initialize the cache
cache.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
login_manager.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
app.register_blueprint(main)
#API resources
api = Api(app)
api.add_resource(HeartbeatReceiver,
"/api/heartbeat/<string:deviceID>/<int:statuscode>")
return app
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. cron_ui.settings.ProdConfig
env: The name of the current environment, e.g. prod or dev
"""
UPLOAD_FOLDER = os.path.dirname(os.path.abspath(__file__)) + '/uploads'
app = Flask(__name__)
app.config.from_object(object_name)
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
# initialize the cache
cache.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
login_manager.init_app(app)
# Impor t and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# register our blueprints
app.register_blueprint(main)
return app
def create_app():
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
"""
app = Flask(__name__)
#app.config.from_object(object_name)
env = DotEnv()
env.init_app(app=app,
env_file=fs.getApplicationDirectory() + os.path.sep + '.env')
for k, v in app.config.items():
if isinstance(v, str):
v = v.lower().strip()
if v == 'true':
app.config[k] = True
elif v == 'false':
app.config[k] = False
# initialize the cache
cache.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
login_manager.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
modules.init_app(app)
return app
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. appname.settings.ProdConfig
"""
app = Flask(__name__)
app.config.from_object(object_name)
# initialize the cache
cache.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
# initalize Flask Login
login_manager.init_app(app)
# initialize Flask-RQ2 (job queue)
rq2.init_app(app)
token.init_app(app)
mail.init_app(app)
limiter.init_app(app)
stripe.init_app(app)
if app.config.get('SENTRY_DSN') and not app.debug:
sentry.init_app(app, dsn=app.config.get('SENTRY_DSN'))
@app.errorhandler(500)
def internal_server_error(error):
return render_template(
'errors/500.html',
event_id=g.sentry_event_id,
public_dsn=sentry.client.get_public_dsn('https')), 500
@app.errorhandler(404)
def not_found_error(error):
if request.path.startswith("/api"):
return api_blueprint.handle_error(error)
return render_template('errors/404.html'), 404
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# Set some globals for Jinja templating
app.jinja_env.globals.update({'utils': utils, 'debug': app.debug})
# register our blueprints
app.register_blueprint(main)
app.register_blueprint(auth)
app.register_blueprint(dashboard)
app.register_blueprint(store)
app.register_blueprint(api_blueprint, url_prefix='/api')
app.register_blueprint(oauth_client, url_prefix='/oauth')
# Admin Tools
app.register_blueprint(jobs, url_prefix='/admin/rq')
admin.init_app(app)
# If you use websockets/realtime features
# socketio.init_app(app)
return app
from app import assets
from app.utils.auth import Auth
# Config
app = Flask(__name__)
env = os.environ.get('FACTURE_ENV', 'dev')
app.config.from_object('config.%sConfig' % env.capitalize())
auth = Auth()
# Models
db = SQLAlchemy(app)
from app.models import User
# Assets
assets_env = Environment(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# Import & Register Blueprints
from app.users.views import users
from app.home.views import home
from app.organisations.views import orgs
from app.invoices.views import invoices
app.register_blueprint(home)
app.register_blueprint(users)
app.register_blueprint(orgs)
app.register_blueprint(invoices)
def create_app(default_config_path=None):
"""Create and return a Flask application. Reads a config file path from the
OK_SERVER_CONFIG environment variable. If it is not set, reads from
default_config_path instead. This is so we can default to a development
environment locally, but the app will fail in production if there is no
config file rather than dangerously defaulting to a development environment.
"""
app = Flask(__name__)
config_path = os.getenv('OK_SERVER_CONFIG', default_config_path)
if config_path is None:
raise ValueError(
'No configuration file found'
'Check that the OK_SERVER_CONFIG environment variable is set.')
app.config.from_pyfile(config_path)
# Senty Error Reporting & Other Prod Changes
sentry_dsn = os.getenv('SENTRY_DSN')
if not app.debug:
app.wsgi_app = ProxyFix(app.wsgi_app)
if sentry_dsn:
sentry.init_app(app, dsn=sentry_dsn)
@app.errorhandler(500)
def internal_server_error(error):
return render_template(
'errors/500.html',
event_id=g.sentry_event_id,
public_dsn=sentry.client.get_public_dsn('https')), 500
# In production mode, add log handler to sys.stderr.
app.logger.addHandler(logging.StreamHandler())
app.logger.setLevel(logging.INFO)
@app.errorhandler(404)
def not_found_error(error):
if request.path.startswith("/api"):
return api.handle_error(error)
return render_template('errors/404.html'), 404
# initialize the cache
cache.init_app(app)
# initialize redis task queues
RQ(app)
# Protect All Routes from csrf
csrf.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
# Flask-Login manager
login_manager.init_app(app)
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# custom URL handling
converters.init_app(app)
# custom Jinja rendering
app.jinja_env.globals.update({
'utils':
utils,
'debug':
app.debug,
'instantclick':
app.config.get('INSTANTCLICK', True),
'CSRFForm':
CSRFForm
})
app.jinja_env.filters.update({
'markdown': utils.convert_markdown,
'pluralize': utils.pluralize,
})
# register our blueprints
# OAuth should not need CSRF protection
csrf.exempt(auth)
app.register_blueprint(auth)
csrf.exempt(oauth)
app.register_blueprint(oauth)
app.register_blueprint(student)
app.register_blueprint(admin, url_prefix='/admin')
app.register_blueprint(about, url_prefix='/about')
# Redis Queue dashboard
csrf.exempt(queue)
app.register_blueprint(queue, url_prefix='/rq')
# API does not need CSRF protection
csrf.exempt(api_endpoints)
app.register_blueprint(api_endpoints, url_prefix=API_PREFIX)
return app
def register_bundle(assets_env):
loader = PythonAssetsLoader(__name__)
for name, bundle in iteritems(loader.load_bundles()):
assets_env.register(name, bundle)
def create_app(object_name):
"""
An flask application factory, as explained here:
http://flask.pocoo.org/docs/patterns/appfactories/
Arguments:
object_name: the python path of the config object,
e.g. appname.settings.ProdConfig
"""
app = Flask(__name__)
app.config.from_object(object_name)
# initialize the cache
cache.init_app(app)
# initialize the debug tool bar
debug_toolbar.init_app(app)
# initialize SQLAlchemy
db.init_app(app)
# initalize Flask Login
login_manager.init_app(app)
# initialize Flask-RQ2 (job queue)
rq2.init_app(app)
# CSRF Protection
csrf.init_app(app)
# File Storage
storage.init_app(app)
# Special URL converters
custom_converters.init_app(app)
token.init_app(app)
mail.init_app(app)
limiter.init_app(app)
stripe.init_app(app)
hashids.init_app(app)
if app.config.get('SENTRY_DSN') and not app.debug:
sentry.init_app(app, dsn=app.config.get('SENTRY_DSN'))
@app.errorhandler(500)
def internal_server_error(error):
return render_template(
'errors/500.html',
event_id=g.sentry_event_id,
public_dsn=sentry.client.get_public_dsn('https')), 500
@app.errorhandler(404)
def not_found_error(error):
if request.path.startswith("/api"):
return handle_api_error(error)
return render_template('errors/404.html'), 404
@app.errorhandler(401)
def permission_denied_error(error):
if request.path.startswith("/api"):
return handle_api_error(error)
return render_template('tabler/401.html'), 401
@app.before_request
def check_for_confirmation(*args, **kwargs):
pass
# TODO: Check later.
# if REQUIRE_EMAIL_CONFIRMATION:
# # If we have a logged in user, we can check if they have confirmed their email or not.
# if not current_user.is_authenticated or current_user.email_confirmed:
# return
# resend_confirm_link = url_for('auth.resend_confirmation')
# text = Markup(
# 'Please confirm your email. '
# '<a href="{}" class="alert-link">Click here to resend</a>'.format(resend_confirm_link))
# flash(text, 'warning')
# Import and register the different asset bundles
assets_env.init_app(app)
assets_loader = PythonAssetsLoader(assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
# Set some globals for Jinja templating
app.jinja_env.globals.update({
'utils': utils,
'view_helpers': view_helpers,
'debug': app.debug,
'constants': constants,
'simple_form': SimpleForm,
'features': {
'oauth': app.config["GOOGLE_OAUTH_CLIENT_ID"] != 'bad_key',
'segment': app.config["SEGMENT_ANALYTICS_KEY"],
},
})
# register our blueprints
app.register_blueprint(main)
app.register_blueprint(auth)
app.register_blueprint(google_blueprint, url_prefix='/oauth')
app.register_blueprint(store)
app.register_blueprint(settings_blueprint)
# Register user dashboard blueprints
for blueprint in dashboard_blueprints:
app.register_blueprint(blueprint, url_prefix='/dashboard')
# API
app.register_blueprint(api_blueprint, url_prefix='/api')
csrf.exempt(api_blueprint)
app.register_blueprint(stripe_blueprint, url_prefix='/webhooks')
csrf.exempt(stripe_blueprint)
# Admin Tools
app.register_blueprint(jobs, url_prefix='/admin/rq')
admin.init_app(app)
# If you use websockets/realtime features
# socketio.init_app(app)
return app
from flask import Flask
from flask_assets import Environment
from flask_sqlalchemy import SQLAlchemy
from webassets.loaders import PythonLoader as PythonAssetsLoader
import webapp.assets
app = Flask(__name__)
app.config.from_pyfile('../config.py')
db = SQLAlchemy(app)
assets_env = Environment(app)
assets_loader = PythonAssetsLoader(webapp.assets)
for name, bundle in assets_loader.load_bundles().items():
assets_env.register(name, bundle)
#import app.forms
import webapp.views
if __name__ == "__main__":
app.debug = True
app.run(host='0.0.0.0')
def init_app(app):
db.init_app(app)
cache.init_app(app)
debug_toolbar.init_app(app)
app.template_folder = os.path.join(os.path.dirname(__file__), 'templates/')
migrate = Migrate(app, db)
# Import and register the different asset bundles
assets_env = Environment(app)
assets_env.load_path = [os.path.join(os.path.dirname(__file__), 'static')]
assets_env.directory = os.path.join(os.path.dirname(__file__), 'static')
assets_env.url = '/admin/static/'
# assets_env.register('js_all', js)
print("directory ", assets_env.directory,
os.path.join(os.path.dirname(__file__), 'static/'))
assets_loader = PythonAssetsLoader(assets)
for name, bundle in list(assets_loader.load_bundles().items()):
assets_env.register(name, bundle)
# Setup user handling
from silverflask.models import User
user_adapter = SQLAlchemyAdapter(db, User)
user_manager = UserManager(user_adapter)
user_manager.init_app(app)
###
# SILVERFLASK
###
upload_path = os.path.join(app.instance_path,
app.config["SILVERFLASK_UPLOAD_PATH"])
app.config["SILVERFLASK_ABSOLUTE_UPLOAD_PATH"] = upload_path
app.storage_backend = LocalFileStorageBackend(upload_path)
from silverflask.controllers.page_controller import SiteTreeController
app.register_blueprint(SiteTreeController.create_blueprint(app))
from silverflask.core.dev_controller import DevController
app.register_blueprint(DevController.create_blueprint(app))
from silverflask.controllers.cms_controller import CMSController, PagesCMSController, FilesCMSController, \
DataObjectCMSController
app.register_blueprint(CMSController.create_blueprint(app))
app.register_blueprint(DataObjectCMSController.create_blueprint(app))
app.register_blueprint(PagesCMSController.create_blueprint(app))
app.register_blueprint(FilesCMSController.create_blueprint(app))
from silverflask.controllers.security_controller import SecurityController
app.register_blueprint(SecurityController.create_blueprint(app))
from silverflask.core.theme import init_themes
init_themes(app)
from silverflask.controllers.main import setup_processors, init_blueprint
from silverflask.controllers.cms import bp as cms_bp
setup_processors(app)
main = init_blueprint(app)
app.register_blueprint(main)
app.register_blueprint(cms_bp, url_prefix='/admin')
# for rule in app.url_map.iter_rules():
# print(rule)
return app
