def create_app(config=None):
from flask import Flask
from server.views import routs as view_routs
from server.api import routs as api_routs
from server.database import db
app = Flask(
__name__,
static_folder='frontend/dist/assets',
template_folder='frontend/dist/templates',
instance_relative_config=True
)
app.config.from_object('config')
app.config.from_pyfile('config.py', silent=True)
if config:
app.config.update(config)
db.init_app(app)
app.register_blueprint(view_routs.view_blueprint)
app.register_blueprint(api_routs.api_blueprint)
return app
def create_app(override_config=None):
app = Flask(__name__)
app.config.from_object(os.environ['APP_SETTINGS'])
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
if override_config is not None:
app.config.from_object(override_config)
create_dir_if_none(app.config['PHOTO_UPLOAD_FOLDER'])
db.init_app(app)
migrate.init_app(app, db)
login_manager.init_app(app)
mail.init_app(app)
socketio.init_app(app)
app.task_queues = {
'high': Queue('high', connection=conn),
'default': Queue('default', connection=conn),
'low': Queue('low', connection=conn)
}
app.register_blueprint(sockets)
app.register_blueprint(home)
app.register_blueprint(upload)
app.register_blueprint(webapp)
app.register_blueprint(signed_upload)
return app
def create_app():
import core.config
connexion_app = connexion.App(__name__, specification_dir='api/')
_app = connexion_app.app
_app.jinja_loader = FileSystemLoader(['server/templates'])
_app.config.update(
# CHANGE SECRET KEY AND SECURITY PASSWORD SALT!!!
SECRET_KEY=core.config.config.secret_key,
SQLALCHEMY_DATABASE_URI=format_db_path(
core.config.config.walkoff_db_type,
os.path.abspath(paths.db_path)),
SECURITY_PASSWORD_HASH='pbkdf2_sha512',
SECURITY_TRACKABLE=False,
SECURITY_PASSWORD_SALT='something_super_secret_change_in_production',
SECURITY_POST_LOGIN_VIEW='/',
WTF_CSRF_ENABLED=False,
JWT_BLACKLIST_ENABLED=True,
JWT_BLACKLIST_TOKEN_CHECKS=['refresh'],
JWT_TOKEN_LOCATION='headers',
SQLALCHEMY_TRACK_MODIFICATIONS=False)
from server.database import db
db.init_app(_app)
from server.security import jwt
jwt.init_app(_app)
connexion_app.add_api('composed_api.yaml')
core.config.config.initialize()
register_blueprints(_app)
import core.controller
core.controller.controller.load_playbooks()
return _app
def create_app():
# creates the app
app = Flask(__name__,
static_folder='../static/dist',
template_folder='../static/templates')
# config
devConfig = Path(os.path.join(app.instance_path, 'devConfig.py'))
prodConfig = Path(os.path.join(app.instance_path, 'prodConfig.py'))
# dev over prod
if devConfig.is_file():
from instance.devConfig import DevelopmentConfig
app.config.from_object(DevelopmentConfig)
elif prodConfig.is_file():
from instance.prodConfig import ProductionConfig
app.config.from_object(ProductionConfig)
# database
with app.app_context():
db.init_app(app)
db.create_all()
# views
with app.app_context():
from server import views
# populates test database entries
with app.app_context():
initialContent.insertAds()
return app
def db(app, request):
"""The app database with fresh set of tables."""
_db.init_app(app)
_db.drop_all()
_db.create_all()
return _db
def create_app(config=None):
app = Flask(__name__)
if config:
app.config.from_object(config)
else:
app.config.from_object(Config)
if app.config.get("SQLALCHEMY_DATABASE_URI"):
db.init_app(app)
db.app = app
init_db(db)
return app
def create_app(config, debug):
app = Flask(__name__)
app.secret_key = config["APP"]["SECRET_KEY"]
app.config['SQLALCHEMY_DATABASE_URI'] = config['DATABASE']['URI']
from server.database import db
db.init_app(app)
nfe_blueprint = create_nfe_blueprint(debug, db)
db_blueprint = create_db_blueprint(debug, db)
app.register_blueprint(nfe_blueprint, url_prefix="/nfe")
app.register_blueprint(db_blueprint, url_prefix="/db")
return app
def create_app():
# creates the app
app = Flask(
__name__,
static_folder=os.path.join(parent_dir, 'assets'),
template_folder=os.path.join(parent_dir, 'templates'),
)
# loads config
config = Path(os.path.join(app.instance_path, 'config.py'))
# dev config
# from instance.config import dev_config
# app.config.from_object(dev_config)
# prod config
from instance.config import prod_config
app.config.from_object(prod_config)
# views
with app.app_context():
from server import views
# projects
from server.projects import api as projects_api
app.register_blueprint(projects_api.bp)
# tags
from server.tags import api as tags_api
app.register_blueprint(tags_api.bp)
# post
from server.post import api as post_api
app.register_blueprint(post_api.bp)
# databbase
with app.app_context():
db.init_app(app)
db.create_all()
# test data
with app.app_context():
from server.test_data import inject_test_data
inject_test_data()
return app
def app(database):
"""
Create a Flask app context for the tests.
"""
from main import app
with app.app_context():
db.init_app(app)
db.create_all()
# migrate = Migrate(app, db)
# api.init_app(app)
yield app
with app.app_context():
# clean up : revert DB to a clean state
db.session.remove()
db.session.commit()
db.session.close_all()
db.drop_all()
db.engine.dispose()
def create_app():
# creates the app
app = Flask(__name__,
static_folder='../static/dist',
template_folder='../static/templates')
# configuration
from instance.config import Configuration
app.config.from_object(Configuration)
# views
with app.app_context():
from server import views
from server import ai
# database
with app.app_context():
db.init_app(app)
db.create_all()
return app
import logging
import sys
from server import config
from server.database import db
from server.cache import cache, get_view_func
from server.web import app
logger = logging.getLogger(__name__)
if __name__ == "__main__":
db.init_app(app)
cache.init_app(app)
logger = logging.getLogger("server")
sqla_logger = logging.getLogger("sqlalchemy")
handler = logging.StreamHandler(stream=sys.stdout)
logger.addHandler(handler)
logger.setLevel(logging.INFO)
sqla_logger.addHandler(handler)
sqla_logger.setLevel(logging.DEBUG)
items = [(key, value) for key, value in config.__dict__.iteritems() if key.startswith("APP_") or key.startswith("DB_")]
for key, value in sorted(items, key=lambda t: t[0]):
logger.info("{:>20}: {}".format(key, str(value)))
# And off we go!
app.run(port=config.APP_PORT, host=config.APP_HOST, debug=config.APP_DEBUG)
